AuroraSupport/AuroraRuntime
2
1
Fork 0
Code Issues 27 Pull Requests Releases Wiki Activity

[*] Fix issues related to inconstent retardation in the asinine freetard world

Browse Source 
GNU and its consequences have been a disaster for the human race
This commit is contained in:
Reece Wilson 2023-08-26 12:18:10 +01:00
parent 502987a38e
commit 3ca8de022e
6 changed files with 89 additions and 40 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
Source/AuProcAddresses.Linux.cpp
View File

@ -9,6 +9,8 @@
#include <sys/syscall.h>
#include <linux/futex.h>
#define AURORA_IS_GLIBC
namespace Aurora
{
#define read_barrier() __asm__ __volatile__("lfence" ::: "memory")
@ -20,32 +22,67 @@ namespace Aurora
}
template <typename... T>
long syscallFuckYou(T &&... args)
{
// sysdeps/unix/sysv/linux/x86_64/syscall.S
// Freetards deserve the rope
long iFuckResult = syscall(AuForward<T &&>(args)...);
#if defined(AURORA_IS_GLIBC)
if (iFuckResult == -1
&& errno < 0)
{
// Lynch freetards
return (0 - errno);
}
#else
// TODO: if defined UNIX has a libc wrapper. why would we assume there's a CRT to begin with?
errno = (0 - iFuckResult);
#endif
// Hit freetards over the head with a baseball bat
return iFuckResult;
// Imagine going out of your way to define a varadic syscall wrapper that works without any special formatting parameters,
// works across all abis, just to fuck it into uselessness by returning -ENOSYS and -1 spuriously.
// Nooo we cant just have all the != 0 and if (n >= 0) checks pass, we must enforce `error == -1` is true everywhere as a convention!!!
// People trying to interface with the kernel directly must never know what the kernel actually said!!!
// Look through all their (GNU) garbage hand written assembly *and* C macros, you'll see its litered with SYSCALL_ERROR_LABEL,
// because i swear to god it looks like cmpq and jae are the only instructions they know how to use.
// Worse, its rationalized as and I quote,
// "Linus said he will make sure the no syscall returns a value in -1 .. -4095 as a valid result so we can safely test with -4095"
// So these copy/pasted instructions are hard-coding a "linus said so once"-based test, and now Linux-like OSes are forever limited to 4k errors?
// I guess it's like the other FUTEX issue where every single thead and every single process under Linux is bound to one ABI defined by glib,
// and the kernels stance on the matter is, I quote "must only be changed if the change is first communicated with the glibc folks."
// That meaning, it doesn't matter because they're just going to half-ass things together holding hands.
// Daily reminder, Lin-shit is half-assed HW abstraction layer held together with forced driver source sharing and glibc+freeedesktop hopes and dreams.
// Fucking retards, I swear
}
int pidfd_getfd(int pidfd, int targetfd,
unsigned int flags)
{
return syscall(SYS_pidfd_getfd, pidfd, targetfd, flags);
return syscallFuckYou(SYS_pidfd_getfd, pidfd, targetfd, flags);
}
int pidfd_open(pid_t pid, unsigned int flags)
{
return syscall(SYS_pidfd_open, pid, flags);
return syscallFuckYou(SYS_pidfd_open, pid, flags);
}
long set_robust_list(struct robust_list_head *head, size_t len)
{
return syscall(SYS_set_robust_list, head, len);
return syscallFuckYou(SYS_set_robust_list, head, len);
}
long get_robust_list(int pid, struct robust_list_head **head_ptr, size_t *len_ptr)
{
return syscall(SYS_get_robust_list, pid, head_ptr, len_ptr);
return syscallFuckYou(SYS_get_robust_list, pid, head_ptr, len_ptr);
}
static int futex(uint32_t *uaddr, int futex_op, uint32_t val,
const struct timespec *timeout,
uint32_t *uaddr2, uint32_t val3)
{
return syscall(SYS_futex, uaddr, futex_op, val, timeout, uaddr2, val3);
return syscallFuckYou(SYS_futex, uaddr, futex_op, val, timeout, uaddr2, val3);
}
int futex_wait(uint32_t *addr, uint32_t expected)
@ -111,17 +148,17 @@ namespace Aurora
int io_setup(unsigned nr, aio_context_t *ctxp)
{
return syscall(__NR_io_setup, nr, ctxp);
return syscallFuckYou(__NR_io_setup, nr, ctxp);
}
int io_destroy(aio_context_t ctx)
{
return syscall(__NR_io_destroy, ctx);
return syscallFuckYou(__NR_io_destroy, ctx);
}
int io_submit(aio_context_t ctx, long nr, struct iocb **iocbpp)
{
return syscall(__NR_io_submit, ctx, nr, iocbpp);
return syscallFuckYou(__NR_io_submit, ctx, nr, iocbpp);
}
#if 0
@ -191,16 +228,28 @@ namespace Aurora
}
do_syscall:
return syscall(__NR_io_getevents,
int iKernelCount {};
if ((iKernelCount = syscallFuckYou(__NR_io_getevents,
ctx, min_nr - i,
max_nr - i,
&events[i], timeout) + i;
&events[i], timeout)) > 0)
{
return i + iKernelCount;
}
else if (i)
{
return i;
}
else
{
return iKernelCount;
}
}
int io_cancel(aio_context_t ctx_id, struct iocb *iocb,
struct io_event *result)
{
return syscall(SYS_io_cancel, ctx_id, iocb, result);
return syscallFuckYou(SYS_io_cancel, ctx_id, iocb, result);
}
ssize_t sys_getrandom(void *pBuffer, size_t uLength)
@ -210,11 +259,11 @@ namespace Aurora
if (gShouldNotGetRand)
{
return ENOSYS;
return -ENOSYS;
}
ret = syscall(SYS_getrandom, pBuffer, uLength, 1);
if (ret == ENOSYS)
ret = syscallFuckYou(SYS_getrandom, pBuffer, uLength, 1);
if (ret == -ENOSYS)
{
gShouldNotGetRand = 1;
}

12
Source/Threading/AuWakeOnAddress.cpp
View File

@ -488,17 +488,17 @@ namespace Aurora::Threading
continue;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
continue;
}
if (ret == ETIMEDOUT || errno == ETIMEDOUT)
if (ret == -ETIMEDOUT)
{
return false;
}
}
while (ret == EINTR);
while (ret == -EINTR);
return !expect.Compare(pTargetAddress);
#endif
@ -695,17 +695,17 @@ namespace Aurora::Threading
continue;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
continue;
}
if (ret == ETIMEDOUT || errno == ETIMEDOUT)
if (ret == -ETIMEDOUT)
{
return false;
}
}
while (ret == EINTR);
while (ret == -EINTR);
#endif

10
Source/Threading/Primitives/AuConditionMutex.Linux.cpp
View File

@ -82,7 +82,7 @@ namespace Aurora::Threading::Primitives
{
ret = futex_wait(&this->uState_, state, &tspec);
}
while (ret == EINTR);
while (ret == -EINTR);
}
else
{
@ -97,14 +97,14 @@ namespace Aurora::Threading::Primitives
break;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
bStatus = true;
break;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "Mutex wait failed: {}", ret)
}
@ -166,14 +166,14 @@ namespace Aurora::Threading::Primitives
break;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
bStatus = true;
break;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "Mutex wait failed: {}", ret)

6
Source/Threading/Primitives/AuConditionVariable.Linux.cpp
View File

@ -63,7 +63,7 @@ namespace Aurora::Threading::Primitives
{
ret = futex_wait(&this->uState_, 0, &tspec);
}
while (ret == EINTR);
while (ret == -EINTR);
}
else
{
@ -78,14 +78,14 @@ namespace Aurora::Threading::Primitives
continue;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
bStatus = true;
continue;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "Condvar wait failed: {}", ret)
}

6
Source/Threading/Primitives/AuMutex.Linux.cpp
View File

@ -108,7 +108,7 @@ namespace Aurora::Threading::Primitives
{
ret = futex_wait(&this->state_, state, &tspec);
}
while (ret == EINTR);
while (ret == -EINTR);
}
else
{
@ -123,14 +123,14 @@ namespace Aurora::Threading::Primitives
break;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == EAGAIN)
{
bStatus = true;
break;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "Mutex wait failed: {}", ret)
}

12
Source/Threading/Primitives/AuSemaphore.Linux.cpp
View File

@ -109,7 +109,7 @@ namespace Aurora::Threading::Primitives
{
ret = futex_wait(&this->dwState_, 0, &tspec);
}
while (ret == EINTR);
while (ret == -EINTR);
}
else
{
@ -124,14 +124,14 @@ namespace Aurora::Threading::Primitives
continue;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
bStatus = true;
continue;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "semaphore wait failed: {}", ret)
}
@ -192,7 +192,7 @@ namespace Aurora::Threading::Primitives
{
ret = futex_wait(&this->dwState_, 0, &tspec);
}
while (ret == EINTR);
while (ret == -EINTR);
}
else
{
@ -207,14 +207,14 @@ namespace Aurora::Threading::Primitives
continue;
}
if (ret == EAGAIN || errno == EAGAIN)
if (ret == -EAGAIN)
{
bStatus = true;
continue;
}
}
while (ret == EINTR);
while (ret == -EINTR);
RUNTIME_ASSERT_SHUTDOWN_SAFE(bStatus, "semaphore wait failed: {}", ret)
}