mirror of
https://github.com/Fennix-Project/Kernel.git
synced 2025-07-11 07:19:20 +00:00
Refactor filesystem & stl code
This commit is contained in:
EnderIce2
@ -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";
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -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
82
library/std/new.cpp
Normal 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
41
library/std/printf.cpp
Normal 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;
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user