Refactor filesystem & stl code

This commit is contained in:
EnderIce2
2024-05-18 07:42:01 +03:00
parent 77a291d08b
commit 6801475243
186 changed files with 15784 additions and 9746 deletions

View File

@ -32,274 +32,178 @@ EXTERNC int *__errno_location(void)
return &thisThread->ErrorNumber;
}
const char *strerror(int errnum)
char *strerror(int errnum)
{
if (errnum < 0)
errnum = -errnum;
switch (errnum)
{
case 0:
return "Success";
case EPERM:
return "Operation not permitted";
case ENOENT:
return "No such file or directory";
case ESRCH:
return "No such process";
case EINTR:
return "Interrupted system call";
case EIO:
return "Input/output error";
case ENXIO:
return "No such device or address";
case EOK:
return (char *)"No error";
case E2BIG:
return "Argument list too long";
case ENOEXEC:
return "Exec format error";
case EBADF:
return "Bad file descriptor";
case ECHILD:
return "No child processes";
case EAGAIN:
return "Resource temporarily unavailable";
case ENOMEM:
return "Cannot allocate memory";
return (char *)"Argument list too long";
case EACCES:
return "Permission denied";
case EFAULT:
return "Bad address";
case ENOTBLK:
return "Block device required";
case EBUSY:
return "Device or resource busy";
case EEXIST:
return "File exists";
case EXDEV:
return "Invalid cross-device link";
case ENODEV:
return "No such device";
case ENOTDIR:
return "Not a directory";
case EISDIR:
return "Is a directory";
case EINVAL:
return "Invalid argument";
case ENFILE:
return "Too many open files in system";
case EMFILE:
return "Too many open files";
case ENOTTY:
return "Inappropriate ioctl for device";
case ETXTBSY:
return "Text file busy";
case EFBIG:
return "File too large";
case ENOSPC:
return "No space left on device";
case ESPIPE:
return "Illegal seek";
case EROFS:
return "Read-only file system";
case EMLINK:
return "Too many links";
case EPIPE:
return "Broken pipe";
case EDOM:
return "Numerical argument out of domain";
case ERANGE:
return "Numerical result out of range";
case EDEADLK:
return "Resource deadlock avoided";
case ENAMETOOLONG:
return "File name too long";
case ENOLCK:
return "No locks available";
case ENOSYS:
return "Function not implemented";
case ENOTEMPTY:
return "Directory not empty";
case ELOOP:
return "Too many levels of symbolic links";
case ENOMSG:
return "No message of desired type";
case EIDRM:
return "Identifier removed";
case ECHRNG:
return "Channel number out of range";
case EL2NSYNC:
return "Level 2 not synchronized";
case EL3HLT:
return "Level 3 halted";
case EL3RST:
return "Level 3 reset";
case ELNRNG:
return "Link number out of range";
case EUNATCH:
return "Protocol driver not attached";
case ENOCSI:
return "No CSI structure available";
case EL2HLT:
return "Level 2 halted";
case EBADE:
return "Invalid exchange";
case EBADR:
return "Invalid request descriptor";
case EXFULL:
return "Exchange full";
case ENOANO:
return "No anode";
case EBADRQC:
return "Invalid request code";
case EBADSLT:
return "Invalid slot";
case EBFONT:
return "Bad font file format";
case ENOSTR:
return "Device not a stream";
case ENODATA:
return "No data available";
case ETIME:
return "Timer expired";
case ENOSR:
return "Out of streams resources";
case ENONET:
return "Machine is not on the network";
case ENOPKG:
return "Package not installed";
case EREMOTE:
return "Object is remote";
case ENOLINK:
return "Link has been severed";
case EADV:
return "Advertise error";
case ESRMNT:
return "Srmount error";
case ECOMM:
return "Communication error on send";
case EPROTO:
return "Protocol error";
case EMULTIHOP:
return "Multihop attempted";
case EDOTDOT:
return "RFS specific error";
case EBADMSG:
return "Bad message";
case EOVERFLOW:
return "Value too large for defined data type";
case ENOTUNIQ:
return "Name not unique on network";
case EBADFD:
return "File descriptor in bad state";
case EREMCHG:
return "Remote address changed";
case ELIBACC:
return "Can not access a needed shared library";
case ELIBBAD:
return "Accessing a corrupted shared library";
case ELIBSCN:
return ".lib section in a.out corrupted";
case ELIBMAX:
return "Attempting to link in too many shared libraries";
case ELIBEXEC:
return "Cannot exec a shared library directly";
case EILSEQ:
return "Illegal byte sequence";
case ERESTART:
return "Interrupted system call should be restarted";
case ESTRPIPE:
return "Streams pipe error";
case EUSERS:
return "Too many users";
case ENOTSOCK:
return "Socket operation on non-socket";
case EDESTADDRREQ:
return "Destination address required";
case EMSGSIZE:
return "Message too long";
case EPROTOTYPE:
return "Protocol wrong type for socket";
case ENOPROTOOPT:
return "Protocol not available";
case EPROTONOSUPPORT:
return "Protocol not supported";
case ESOCKTNOSUPPORT:
return "Socket type not supported";
case EOPNOTSUPP:
return "Operation not supported";
case EPFNOSUPPORT:
return "Protocol family not supported";
case EAFNOSUPPORT:
return "Address family not supported by protocol";
return (char *)"Permission denied";
case EADDRINUSE:
return "Address already in use";
return (char *)"Address in use";
case EADDRNOTAVAIL:
return "Cannot assign requested address";
case ENETDOWN:
return "Network is down";
case ENETUNREACH:
return "Network is unreachable";
case ENETRESET:
return "Network dropped connection on reset";
case ECONNABORTED:
return "Software caused connection abort";
case ECONNRESET:
return "Connection reset by peer";
case ENOBUFS:
return "No buffer space available";
case EISCONN:
return "Transport endpoint is already connected";
case ENOTCONN:
return "Transport endpoint is not connected";
case ESHUTDOWN:
return "Cannot send after transport endpoint shutdown";
case ETOOMANYREFS:
return "Too many references: cannot splice";
case ETIMEDOUT:
return "Connection timed out";
case ECONNREFUSED:
return "Connection refused";
case EHOSTDOWN:
return "Host is down";
case EHOSTUNREACH:
return "No route to host";
return (char *)"Address not available";
case EAFNOSUPPORT:
return (char *)"Address family not supported";
case EAGAIN:
return (char *)"Resource unavailable, try again";
case EALREADY:
return "Operation already in progress";
case EINPROGRESS:
return "Operation now in progress";
case ESTALE:
return "Stale file handle";
case EUCLEAN:
return "Structure needs cleaning";
case ENOTNAM:
return "Not a XENIX named type file";
case ENAVAIL:
return "No XENIX semaphores available";
case EISNAM:
return "Is a named type file";
case EREMOTEIO:
return "Remote I/O error";
case EDQUOT:
return "Quota exceeded";
case ENOMEDIUM:
return "No medium found";
case EMEDIUMTYPE:
return "Wrong medium type";
return (char *)"Connection already in progress";
case EBADF:
return (char *)"Bad file descriptor";
case EBADMSG:
return (char *)"Bad message";
case EBUSY:
return (char *)"Device or resource busy";
case ECANCELED:
return "Operation Canceled";
case ENOKEY:
return "Required key not available";
case EKEYEXPIRED:
return "Key has expired";
case EKEYREVOKED:
return "Key has been revoked";
case EKEYREJECTED:
return "Key was rejected by service";
case EOWNERDEAD:
return "Owner died";
return (char *)"Operation canceled";
case ECHILD:
return (char *)"No child processes";
case ECONNABORTED:
return (char *)"Connection aborted";
case ECONNREFUSED:
return (char *)"Connection refused";
case ECONNRESET:
return (char *)"Connection reset";
case EDEADLK:
return (char *)"Resource deadlock would occur";
case EDESTADDRREQ:
return (char *)"Destination address required";
case EDOM:
return (char *)"Mathematics argument out of domain of function";
case EDQUOT:
return (char *)"Reserved";
case EEXIST:
return (char *)"File exists";
case EFAULT:
return (char *)"Bad address";
case EFBIG:
return (char *)"File too large";
case EHOSTUNREACH:
return (char *)"Host is unreachable";
case EIDRM:
return (char *)"Identifier removed";
case EILSEQ:
return (char *)"Illegal byte sequence";
case EINPROGRESS:
return (char *)"Operation in progress";
case EINTR:
return (char *)"Interrupted function";
case EINVAL:
return (char *)"Invalid argument";
case EIO:
return (char *)"I/O error";
case EISCONN:
return (char *)"Socket is connected";
case EISDIR:
return (char *)"Is a directory";
case ELOOP:
return (char *)"Too many levels of symbolic links";
case EMFILE:
return (char *)"File descriptor value too large";
case EMLINK:
return (char *)"Too many links";
case EMSGSIZE:
return (char *)"Message too large";
case EMULTIHOP:
return (char *)"Reserved";
case ENAMETOOLONG:
return (char *)"Filename too long";
case ENETDOWN:
return (char *)"Network is down";
case ENETRESET:
return (char *)"Connection aborted by network";
case ENETUNREACH:
return (char *)"Network unreachable";
case ENFILE:
return (char *)"Too many files open in system";
case ENOBUFS:
return (char *)"No buffer space available";
case ENODATA:
return (char *)"No message available on the STREAM head read queue";
case ENODEV:
return (char *)"No such device";
case ENOENT:
return (char *)"No such file or directory";
case ENOEXEC:
return (char *)"Executable file format error";
case ENOLCK:
return (char *)"No locks available";
case ENOLINK:
return (char *)"Reserved";
case ENOMEM:
return (char *)"Not enough space";
case ENOMSG:
return (char *)"No message of the desired type";
case ENOPROTOOPT:
return (char *)"Protocol not available";
case ENOSPC:
return (char *)"No space left on device";
case ENOSR:
return (char *)"No STREAM resources";
case ENOSTR:
return (char *)"Not a STREAM";
case ENOSYS:
return (char *)"Functionality not supported";
case ENOTCONN:
return (char *)"The socket is not connected";
case ENOTDIR:
return (char *)"Not a directory or a symbolic link to a directory";
case ENOTEMPTY:
return (char *)"Directory not empty";
case ENOTRECOVERABLE:
return "State not recoverable";
return (char *)"State not recoverable";
case ENOTSOCK:
return (char *)"Not a socket";
case ENOTSUP:
return (char *)"Not supported";
case ENOTTY:
return (char *)"Inappropriate I/O control operation";
case ENXIO:
return (char *)"No such device or address";
case EOPNOTSUPP:
return (char *)"Operation not supported on socket";
case EOVERFLOW:
return (char *)"Value too large to be stored in data type";
case EOWNERDEAD:
return (char *)"Previous owner died";
case EPERM:
return (char *)"Operation not permitted";
case EPIPE:
return (char *)"Broken pipe";
case EPROTO:
return (char *)"Protocol error";
case EPROTONOSUPPORT:
return (char *)"Protocol not supported";
case EPROTOTYPE:
return (char *)"Protocol wrong type for socket";
case ERANGE:
return (char *)"Result too large";
case EROFS:
return (char *)"Read-only file system";
case ESPIPE:
return (char *)"Invalid seek";
case ESRCH:
return (char *)"No such process";
case ESTALE:
return (char *)"Reserved";
case ETIME:
return (char *)"Stream ioctl() timeout";
case ETIMEDOUT:
return (char *)"Connection timed out";
case ETXTBSY:
return (char *)"Text file busy";
case EWOULDBLOCK:
return (char *)"Operation would block";
case EXDEV:
return (char *)"Cross-device link";
default:
return "Unknown error";
return (char *)"Unknown error";
}
}
}

View File

@ -33,6 +33,7 @@ namespace std
bool Result = this->Locked.exchange(true, std::memory_order_acquire);
TCB *tcb = thisThread;
assert(tcb != nullptr);
if (Result == true)
{
debug("%#lx: Mutex is locked, blocking task %d (\"%s\" : %d)", this,
@ -56,6 +57,7 @@ namespace std
bool Result = this->Locked.exchange(true, std::memory_order_acquire);
TCB *tcb = thisThread;
assert(tcb != nullptr);
if (Result == true)
{
debug("%#lx: Mutex is locked, task %d (\"%s\" : %d) failed to lock", this,
@ -74,6 +76,7 @@ namespace std
void mutex::unlock()
{
TCB *tcb = thisThread;
assert(tcb != nullptr);
assert(this->Holder == tcb);
this->Holder = nullptr;

82
library/std/new.cpp Normal file
View File

@ -0,0 +1,82 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <new>
#include <memory.hpp>
#include <stdexcept>
void *operator new(std::size_t count)
{
if (count == 0)
++count;
if (void *ptr = kmalloc(count))
return ptr;
throw std::bad_alloc{};
}
void *operator new[](std::size_t count)
{
if (count == 0)
++count;
if (void *ptr = kmalloc(count))
return ptr;
throw std::bad_alloc{};
}
// void *operator new(std::size_t count, std::align_val_t al)
// void *operator new[](std::size_t count, std::align_val_t al)
// void *operator new(std::size_t count, const std::nothrow_t &tag)
// void *operator new[](std::size_t count, const std::nothrow_t &tag)
// void *operator new(std::size_t count, std::align_val_t al, const std::nothrow_t &)
// void *operator new[](std::size_t count, std::align_val_t al, const std::nothrow_t &)
void *operator new(std::size_t, void *ptr) noexcept { return ptr; }
// void *operator new[](std::size_t count, void *ptr) noexcept
// void *operator new(std::size_t count, ...)
// void *operator new[](std::size_t count, ...)
// void *operator new(std::size_t count, std::align_val_t al, ...)
// void *operator new[](std::size_t count, std::align_val_t al, ...)
void operator delete(void *ptr) noexcept { kfree(ptr); }
void operator delete[](void *ptr) noexcept { kfree(ptr); }
// void operator delete(void *ptr, std::align_val_t al) noexcept
// void operator delete[](void *ptr, std::align_val_t al) noexcept
void operator delete(void *ptr, std::size_t) noexcept { kfree(ptr); }
void operator delete[](void *ptr, std::size_t sz) noexcept { kfree(ptr); }
void operator delete(void *ptr, std::size_t sz, std::align_val_t al) noexcept { kfree(ptr); }
// void operator delete[](void *ptr, std::size_t sz, std::align_val_t al) noexcept
// void operator delete(void *ptr, const std::nothrow_t &tag) noexcept
// void operator delete[](void *ptr, const std::nothrow_t &tag) noexcept
// void operator delete(void *ptr, std::align_val_t al, const std::nothrow_t &tag) noexcept
// void operator delete[](void *ptr, std::align_val_t al, const std::nothrow_t &tag) noexcept
// void operator delete(void *ptr, void *place) noexcept
// void operator delete[](void *ptr, void *place) noexcept
// void operator delete(void *ptr, ...)
// void operator delete[](void *ptr, ...)

41
library/std/printf.cpp Normal file
View File

@ -0,0 +1,41 @@
/*
This file is part of Fennix Kernel.
Fennix Kernel is free software: you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation, either version 3 of
the License, or (at your option) any later version.
Fennix Kernel is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Fennix Kernel. If not, see <https://www.gnu.org/licenses/>.
*/
#include <string>
#include <printf.h>
namespace std
{
int sprintf(char *s, const char *format, ...)
{
va_list args;
va_start(args, format);
int ret = vsprintf(s, format, args);
va_end(args);
return ret;
}
int snprintf(char *s, size_t count, const char *format, ...)
{
va_list args;
va_start(args, format);
int ret = vsnprintf(s, count, format, args);
va_end(args);
return ret;
}
}