From a3ed950be8da30d4d7ad9ce85242ad5495a3a8aa Mon Sep 17 00:00:00 2001 From: apio Date: Sat, 22 Jul 2023 00:02:12 +0200 Subject: [PATCH] libc: Basic write buffers --- apps/CMakeLists.txt | 1 + apps/buffer-test.cpp | 27 ++++++++ apps/su.cpp | 1 + libc/include/stdio.h | 18 +++++- libc/src/init.cpp | 11 +++- libc/src/stdio.cpp | 151 +++++++++++++++++++++++++++++++++++++++++-- 6 files changed, 199 insertions(+), 10 deletions(-) create mode 100644 apps/buffer-test.cpp diff --git a/apps/CMakeLists.txt b/apps/CMakeLists.txt index caa2a70b..20d24f19 100644 --- a/apps/CMakeLists.txt +++ b/apps/CMakeLists.txt @@ -41,3 +41,4 @@ luna_app(pivot_root.cpp pivot_root) luna_app(cp.cpp cp) luna_app(kill.cpp kill) luna_app(gol.cpp gol) +luna_app(buffer-test.cpp buffer-test) diff --git a/apps/buffer-test.cpp b/apps/buffer-test.cpp new file mode 100644 index 00000000..ed64bfa3 --- /dev/null +++ b/apps/buffer-test.cpp @@ -0,0 +1,27 @@ +#include +#include +#include + +int main() +{ + fprintf(stderr, "Writing incomplete line to stdout (_IOLBF=%d)...\n", stdout->_mode); + fputs("hi!", stdout); + sleep(3); + putchar('\n'); + fprintf(stderr, "Incomplete line should have been written.\n"); + + FILE* f = fopen("/dev/console", "w+"); + assert(f); + assert(setvbuf(f, NULL, _IOFBF, 0) == 0); + + fprintf(stderr, "Writing long text to file (_IOFBF=%d)...\n", f->_mode); + + fputs("Hello world!\nHow are you doing!\nThis is a test for many lines of buffering.\n", f); + + sleep(3); + fflush(f); + + fprintf(stderr, "Long text should have been written.\n"); + + fclose(f); +} diff --git a/apps/su.cpp b/apps/su.cpp index f1602672..cefcecc7 100644 --- a/apps/su.cpp +++ b/apps/su.cpp @@ -31,6 +31,7 @@ char* getpass() tcsetpgrp(STDIN_FILENO, getpgid(0)); fputs("Password: ", stdout); + fflush(stdout); if (tcgetattr(STDIN_FILENO, &orig) < 0) { diff --git a/libc/include/stdio.h b/libc/include/stdio.h index bab534d0..0e706f52 100644 --- a/libc/include/stdio.h +++ b/libc/include/stdio.h @@ -10,11 +10,20 @@ #define __need_NULL #include +#define FOPEN_MAX 64 // Make sure this value matches FD_MAX in the kernel source. + typedef struct { int _fd; int _err; int _eof; + size_t _bufcap; + size_t _bufsize; + size_t _bufindex; + char* _buffer; + int _flags; + int _pending; + int _mode; } FILE; #define EOF -1 @@ -26,11 +35,15 @@ extern FILE* stderr; #define stdout stdout #define stderr stderr -#define BUFSIZ 1024 +#define BUFSIZ 4096 #define FILENAME_MAX \ 1024 // As Luna does not impose a limit on this, this is the recommended size for character arrays holding a file // name. +#define _IONBF 0 +#define _IOLBF 1 +#define _IOFBF 2 + #ifdef __cplusplus extern "C" { @@ -172,6 +185,9 @@ extern "C" /* Create a unique temporary file. */ FILE* tmpfile(void); + /* Change a file's buffering mode and internal buffer. */ + int setvbuf(FILE* stream, char* buf, int mode, size_t size); + #ifdef __cplusplus } #endif diff --git a/libc/src/init.cpp b/libc/src/init.cpp index a035db2a..e8fe79b9 100644 --- a/libc/src/init.cpp +++ b/libc/src/init.cpp @@ -4,6 +4,9 @@ extern char** environ; +extern "C" FILE* _fdopen_impl(int, const char*, int); +extern "C" void _init_stdio(); + extern "C" { void libc_init(int argc, char** argv, int envc, char** envp) @@ -11,8 +14,10 @@ extern "C" ignore(argc, argv, envc); environ = envp; - stdin = fdopen(STDIN_FILENO, "r"); - stdout = fdopen(STDOUT_FILENO, "w"); - stderr = fdopen(STDERR_FILENO, "w"); + _init_stdio(); + + stdin = _fdopen_impl(STDIN_FILENO, "r", _IOLBF); + stdout = _fdopen_impl(STDOUT_FILENO, "w", _IOLBF); + stderr = _fdopen_impl(STDERR_FILENO, "w", _IONBF); } } diff --git a/libc/src/stdio.cpp b/libc/src/stdio.cpp index 0ce0b5fc..3a01c05b 100644 --- a/libc/src/stdio.cpp +++ b/libc/src/stdio.cpp @@ -11,6 +11,10 @@ FILE* stdin = nullptr; FILE* stderr = nullptr; FILE* stdout = nullptr; +FILE* s_open_files[FOPEN_MAX]; + +#define FFLAG_FREE_AFTER_BUFFER_USE (1 << 0) + static const char* read_tmpdir() { const char* tmpdir = getenv("TMPDIR"); @@ -51,11 +55,71 @@ static int fdopen_check_compatible_mode(int fd, int new_flags) return 0; } +static int flush_write_buffer(FILE* stream) +{ + if (stream->_mode == _IONBF) return 0; + + ssize_t result = write(stream->_fd, stream->_buffer, stream->_bufsize); + + stream->_bufindex = 0; + stream->_bufsize = 0; + + return result < 0 ? EOF : 0; +} + +static ssize_t write_into_buffer(FILE* stream, const u8* data, ssize_t size) +{ + ssize_t total_written = 0; + + while (size > 0) + { + ssize_t nwritten; + if (stream->_mode != _IONBF) + { + if ((stream->_bufsize + size) > stream->_bufcap) + { + if (flush_write_buffer(stream) < 0) return -1; + } + + ssize_t size_remaining = stream->_bufcap - stream->_bufsize; + nwritten = size > size_remaining ? size_remaining : size; + memcpy(stream->_buffer + stream->_bufsize, data, nwritten); + + stream->_bufsize += nwritten; + + if (stream->_mode == _IOLBF && memchr(data, '\n', nwritten)) + { + if (flush_write_buffer(stream) < 0) return -1; + } + } + else + nwritten = write(stream->_fd, data, size > BUFSIZ ? BUFSIZ : size); + if (nwritten < 0) return nwritten; + size -= nwritten; + data += nwritten; + total_written += nwritten; + } + + return total_written; +} + extern "C" { - int fflush(FILE*) + void _init_stdio() { - // FIXME: Files are not buffered right now. + memset(&s_open_files, 0, sizeof(s_open_files)); + } + + int fflush(FILE* stream) + { + if (stream && stream->_mode != _IONBF) flush_write_buffer(stream); + else if (!stream) + { + for (int i = 0; i < FOPEN_MAX; i++) + { + if (s_open_files[i]) fflush(s_open_files[i]); + } + } return 0; } @@ -78,10 +142,19 @@ extern "C" f->_fd = fd; clearerr(f); + f->_pending = 0; + f->_flags = flags; + f->_mode = isatty(fd) ? _IOLBF : _IOFBF; + f->_bufsize = f->_bufindex = 0; + f->_buffer = nullptr; + setvbuf(f, NULL, f->_mode, 0); + + s_open_files[fd] = f; + return f; } - FILE* fdopen(int fd, const char* mode) + FILE* _fdopen_impl(int fd, const char* mode, int buffering_mode) { int flags; @@ -95,9 +168,23 @@ extern "C" f->_fd = fd; clearerr(f); + f->_pending = 0; + f->_flags = flags; + f->_mode = buffering_mode < 0 ? (isatty(fd) ? _IOLBF : _IOFBF) : buffering_mode; + f->_bufsize = f->_bufindex = 0; + f->_buffer = nullptr; + setvbuf(f, NULL, f->_mode, 0); + + s_open_files[fd] = f; + return f; } + FILE* fdopen(int fd, const char* mode) + { + return _fdopen_impl(fd, mode, -1); + } + FILE* freopen(const char* path, const char* mode, FILE* stream) { int flags; @@ -106,6 +193,10 @@ extern "C" close(stream->_fd); + s_open_files[stream->_fd] = nullptr; + + if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer); + if (!path) { fail("FIXME: freopen() called with path=nullptr"); } int fd = open(path, flags, 0666); @@ -114,13 +205,28 @@ extern "C" stream->_fd = fd; clearerr(stream); + stream->_pending = 0; + stream->_flags = flags; + stream->_mode = isatty(fd) ? _IOLBF : _IOFBF; + stream->_bufsize = stream->_bufindex = 0; + stream->_buffer = nullptr; + setvbuf(stream, NULL, stream->_mode, 0); + + s_open_files[fd] = stream; + return stream; } int fclose(FILE* stream) { + if (fflush(stream) < 0) return EOF; + if (close(stream->_fd) < 0) return EOF; + if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer); + + s_open_files[stream->_fd] = nullptr; + free(stream); return 0; @@ -155,7 +261,12 @@ extern "C" { if (size * nmemb == 0) return 0; - ssize_t nwrite = write(stream->_fd, buf, size * nmemb); + ssize_t nwrite = write_into_buffer(stream, (const u8*)buf, size * nmemb); + if (nwrite < 0) + { + stream->_err = 1; + return 0; + } return (size_t)nwrite / size; } @@ -211,7 +322,7 @@ extern "C" int fputc(int c, FILE* stream) { u8 value = (u8)c; - ssize_t rc = write(stream->_fd, &value, 1); + ssize_t rc = write_into_buffer(stream, &value, 1); if (rc <= 0) return EOF; return c; } @@ -228,7 +339,7 @@ extern "C" int fputs(const char* str, FILE* stream) { - ssize_t rc = write(stream->_fd, str, strlen(str)); + ssize_t rc = write_into_buffer(stream, (const u8*)str, strlen(str)); return (rc < 0) ? -1 : 0; } @@ -496,4 +607,32 @@ extern "C" { fail("FIXME: ungetc: not implemented"); } + + int setvbuf(FILE* stream, char* buf, int mode, size_t size) + { + int pending = 0; + if (mode < 0 || mode > _IOFBF) return errno = EINVAL, -1; + if (stream->_bufsize != 0 || stream->_bufindex != 0) return -1; // Buffer is already in use. + if (mode != _IONBF && buf == NULL) + { + size = BUFSIZ; + buf = (char*)calloc(size, 1); + if (!buf) return -1; + pending = FFLAG_FREE_AFTER_BUFFER_USE; + } + else + { + buf = NULL; + size = 0; + } + + if (stream->_buffer && (stream->_pending & FFLAG_FREE_AFTER_BUFFER_USE)) free(stream->_buffer); + + stream->_buffer = buf; + stream->_bufcap = size; + stream->_mode = mode; + stream->_pending = pending; + + return 0; + } }