apio/Luna
1
1
Fork 0
Code Issues Pull Requests Actions Projects Releases 8 Wiki Activity
e37ff67da2
Luna/kernel/src/sys/stdio.cpp

186 lines
4.5 KiB
C++
Raw Normal View History

Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
#define MODULE "stdio"
#include "errno.h"
refine syscalls
2022-09-29 17:17:43 +00:00
#include "interrupts/Context.h"
#include "io/Serial.h"
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
#include "log/Log.h"
Finally, a text renderer that actually works. We can now see the kernel messages without a serial port :)
2022-10-01 12:27:45 +00:00
#include "render/TextRenderer.h"
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
#include "thread/Scheduler.h"
#include "thread/Task.h"
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
#define OPEN_READ 1
#define OPEN_WRITE 2
Kernel: Add a seek() system call Now, time for libc support!!
2022-10-12 13:28:52 +00:00
#define SEEK_SET 0
#define SEEK_CUR 1
#define SEEK_END 2
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
#define STDIO_FAIL(function, error) kwarnln("%s failed with %s", #function, #error)
refine syscalls
2022-09-29 17:17:43 +00:00
Kernel: Add a seek() system call Now, time for libc support!!
2022-10-12 13:28:52 +00:00
void sys_seek(Context* context, int fd, long offset, int whence)
{
if (whence < SEEK_SET || whence > SEEK_END)
{
STDIO_FAIL(seek, EINVAL);
context->rax = -EINVAL;
return;
}
if (fd >= TASK_MAX_FDS || fd < 0)
{
STDIO_FAIL(seek, EBADF);
context->rax = -EBADF;
return;
}
Task* current_task = Scheduler::current_task();
if (!current_task->files[fd].is_open())
{
STDIO_FAIL(seek, EBADF);
context->rax = -EBADF;
return;
}
long new_offset;
if (whence == SEEK_SET) new_offset = offset;
else if (whence == SEEK_CUR)
new_offset = offset + current_task->files[fd].offset();
else if (whence == SEEK_END)
new_offset = current_task->files[fd].length() + offset;
else
__builtin_unreachable();
if (new_offset < 0)
{
STDIO_FAIL(seek, EINVAL);
context->rax = -EINVAL; // FIXME: Is this the right error?
return;
}
int result = current_task->files[fd].seek(new_offset);
if (result < 0)
{
context->rax = result;
return;
}
context->rax = new_offset;
return;
}
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
void sys_write(Context* context, int fd, size_t size, const char* addr)
refine syscalls
2022-09-29 17:17:43 +00:00
{
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
if (!addr)
{
STDIO_FAIL(write, EINVAL);
context->rax = -EINVAL; // FIXME: This should probably return EFAULT.
return;
}
if (fd >= TASK_MAX_FDS || fd < 0)
{
STDIO_FAIL(write, EBADF);
context->rax = -EBADF;
return;
}
Task* current_task = Scheduler::current_task();
if (!current_task->files[fd].is_open())
{
STDIO_FAIL(write, EBADF);
context->rax = -EBADF;
return;
}
if (!current_task->files[fd].can_write())
{
STDIO_FAIL(write, EBADF);
context->rax = -EBADF;
return;
}
ssize_t result = current_task->files[fd].write(size, addr);
context->rax = (size_t)result;
return;
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
}
void sys_open(Context* context, const char* filename, int flags)
{
Task* current_task = Scheduler::current_task();
sys_open(): actually return EMFILE if the process has used all of its file slots
2022-10-11 15:03:16 +00:00
int fd;
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
for (fd = 0; fd < TASK_MAX_FDS; fd++)
{
if (!current_task->files[fd].is_open()) break;
}
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
sys_open(): actually return EMFILE if the process has used all of its file slots
2022-10-11 15:03:16 +00:00
if (fd == TASK_MAX_FDS)
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
{
STDIO_FAIL(open, EMFILE);
context->rax = -EMFILE;
return;
}
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
VFS::Node* node = VFS::resolve_path(filename);
if (!node)
{
STDIO_FAIL(open, ENOENT);
context->rax = -ENOENT;
return;
}
Kernel/syscalls: Modify sys_write to accept a file descriptor and write to it Previously, sys_write only wrote to the tty. Now, it uses the VFS interface, as it should.
2022-10-11 19:06:12 +00:00
bool can_read = (flags & OPEN_READ) > 0;
bool can_write = (flags & OPEN_WRITE) > 0;
if (!can_read && !can_write)
{
STDIO_FAIL(open, EINVAL);
context->rax = -EINVAL;
return;
}
kdbgln("open(): opening %s %s, allocated file descriptor %d", filename,
(can_read && can_write) ? "rw"
: can_read ? "r-"
: "-w",
fd);
current_task->files[fd].open(node, can_read, can_write);
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
context->rax = fd;
return;
}
void sys_read(Context* context, int fd, size_t size, char* buffer)
{
if (!buffer)
{
STDIO_FAIL(read, EINVAL);
Refactor sys/stdio.cpp
2022-10-11 15:10:44 +00:00
context->rax = -EINVAL; // FIXME: This should probably return EFAULT.
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
return;
}
Refactor sys/stdio.cpp
2022-10-11 15:10:44 +00:00
if (fd >= TASK_MAX_FDS || fd < 0)
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
{
STDIO_FAIL(read, EBADF);
context->rax = -EBADF;
return;
}
Task* current_task = Scheduler::current_task();
Refactor sys/stdio.cpp
2022-10-11 15:10:44 +00:00
if (!current_task->files[fd].is_open() || !current_task->files[fd].can_read())
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
{
STDIO_FAIL(read, EBADF);
context->rax = -EBADF;
return;
}
ssize_t result = current_task->files[fd].read(size, buffer);
context->rax = (size_t)result;
return;
}
void sys_close(Context* context, int fd)
{
Refactor sys/stdio.cpp
2022-10-11 15:10:44 +00:00
if (fd >= TASK_MAX_FDS || fd < 0)
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
{
STDIO_FAIL(close, EBADF);
context->rax = -EBADF;
return;
}
Task* current_task = Scheduler::current_task();
if (!current_task->files[fd].is_open())
{
STDIO_FAIL(close, EBADF);
context->rax = -EBADF;
return;
}
stdio: log stuff more
2022-10-11 15:19:03 +00:00
kdbgln("close(): releasing file descriptor %d", fd);
Kernel, libc, userspace: Implement file descriptors Kernel: Implement a descriptor struct which stores the opened node and read offset, and give each task 8 of those. Implement three syscalls: sys_read, sys_open and sys_close (sys_write still writes to the console instead of using a fd, for now) Implement three new errors: ENOENT, EBADF and EMFILE. libc: Implement the new errors, and the new syscalls in syscall(). Also fix _RETURN_WITH_ERRNO() to set errno correctly, which was making strerror() return null, thus crashing perror(). userspace: make init demonstrate the new file API.
2022-10-10 18:21:39 +00:00
current_task->files[fd].close();
context->rax = 0;
return;
refine syscalls
2022-09-29 17:17:43 +00:00
}
Reference in New Issue Copy Permalink