stdio: refactor printk to printf and friends
parent
474974b779
commit
4db1702078
GPG Key ID:
EC22E476DC2D3D84
@ -1,25 +0,0 @@
|
||||
/* See the end of this file for copyright, license, and warranty information. */
|
||||
|
||||
#pragma once
|
||||
|
||||
/**
|
||||
* Print to the kernel log buffer.
|
||||
*
|
||||
* @param fmt: A printf-style format string.
|
||||
* @return The amount of bytes written, or a negative POSIX number
|
||||
*/
|
||||
__attribute__(( format(printf, 1, 2) ))
|
||||
int printk(const char *fmt, ...);
|
||||
|
||||
/*
|
||||
* This file is part of Ardix.
|
||||
* Copyright (c) 2020, 2021 Felix Kopp <owo@fef.moe>.
|
||||
*
|
||||
* Ardix is non-violent software: you may only use, redistribute,
|
||||
* and/or modify it under the terms of the CNPLv6+ as found in
|
||||
* the LICENSE file in the source code root directory or at
|
||||
* <https://git.pixie.town/thufie/CNPL>.
|
||||
*
|
||||
* Ardix comes with ABSOLUTELY NO WARRANTY, to the extent
|
||||
* permitted by applicable law. See the CNPLv6+ for details.
|
||||
*/
|
||||
@ -0,0 +1,44 @@
|
||||
/* See the end of this file for copyright, license, and warranty information. */
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <toolchain.h>
|
||||
|
||||
/*
|
||||
* We sacrifice performance for less memory usage by not having a userland
|
||||
* structure for `FILE`. Instead, we cast the file descriptor to a pointer and
|
||||
* use that for syscalls.
|
||||
*/
|
||||
struct _user_file { void *_undefined; };
|
||||
#define FILE struct _user_file
|
||||
|
||||
#define _file_to_fd(f) ((int)( (intptr_t)(f) ))
|
||||
#define _fd_to_file(fd) ((FILE *)( (intptr_t)(fd) ))
|
||||
|
||||
#define stdin _fd_to_file(0)
|
||||
#define stdout _fd_to_file(1)
|
||||
#define stderr _fd_to_file(2)
|
||||
|
||||
__shared int printf(const char *restrict fmt, ...)
|
||||
__attribute__(( format(printf, 1, 2) ));
|
||||
|
||||
__shared int vprintf(const char *restrict fmt, va_list args);
|
||||
|
||||
__shared int fprintf(FILE *f, const char *restrict fmt, ...)
|
||||
__attribute__(( format(printf, 2, 3) ));
|
||||
|
||||
__shared int vfprintf(FILE *f, const char *restrict fmt, va_list args);
|
||||
|
||||
/*
|
||||
* This file is part of Ardix.
|
||||
* Copyright (c) 2020, 2021 Felix Kopp <owo@fef.moe>.
|
||||
*
|
||||
* Ardix is non-violent software: you may only use, redistribute,
|
||||
* and/or modify it under the terms of the CNPLv6+ as found in
|
||||
* the LICENSE file in the source code root directory or at
|
||||
* <https://git.pixie.town/thufie/CNPL>.
|
||||
*
|
||||
* Ardix comes with ABSOLUTELY NO WARRANTY, to the extent
|
||||
* permitted by applicable law. See the CNPLv6+ for details.
|
||||
*/
|
||||
@ -1,211 +0,0 @@
|
||||
/* See the end of this file for copyright, license, and warranty information. */
|
||||
|
||||
#include <arch/serial.h>
|
||||
|
||||
#include <ardix/dma.h>
|
||||
#include <ardix/printk.h>
|
||||
#include <ardix/ringbuf.h>
|
||||
#include <ardix/serial.h>
|
||||
|
||||
#include <errno.h>
|
||||
/* Using GCC's stdarg.h is recommended even with -nodefaultlibs and -fno-builtin */
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <string.h>
|
||||
#include <toolchain.h>
|
||||
|
||||
#ifndef CONFIG_PRINTK_BUFSZ
|
||||
#define CONFIG_PRINTK_BUFSZ 64
|
||||
#endif
|
||||
|
||||
/*
|
||||
* TODO: THIS CAUSES A STACK BUFFER OVERFLOW ON SYSTEMS WHERE INT IS 64 BITS
|
||||
*/
|
||||
|
||||
/* 10 decimal digits of 4294967295 (2 ** 32 - 1) */
|
||||
#define PRINTK_UINT_BUFSZ 10
|
||||
|
||||
static ssize_t printk_flush(struct ringbuf *buf)
|
||||
{
|
||||
ssize_t ret;
|
||||
struct dmabuf *dma = dmabuf_create(&serial_default_device->device, buf->len);
|
||||
if (dma == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
ringbuf_read(dma->data, buf, buf->len);
|
||||
ret = serial_write_dma(serial_default_device, dma);
|
||||
dmabuf_put(dma);
|
||||
return ret;
|
||||
}
|
||||
|
||||
__rodata static const char fmt_hex_table[] = {
|
||||
'0', '1', '2', '3',
|
||||
'4', '5', '6', '7',
|
||||
'8', '9', 'a', 'b',
|
||||
'c', 'd', 'e', 'f',
|
||||
};
|
||||
|
||||
static int fmt_handle_ptr(struct ringbuf *buf, uintptr_t ptr)
|
||||
{
|
||||
int ret;
|
||||
/* 2 chars per byte, plus 2 for the "0x" hex prefix */
|
||||
char str[2 * sizeof(uintptr_t) + 2];
|
||||
char *pos = &str[2 * sizeof(uintptr_t) + 1];
|
||||
|
||||
str[0] = '0';
|
||||
str[1] = 'x';
|
||||
|
||||
do {
|
||||
*pos-- = fmt_hex_table[ptr & 0xf];
|
||||
ptr >>= 4;
|
||||
} while (pos != &str[2]);
|
||||
|
||||
ret = ringbuf_write(buf, &str[0], 2 * sizeof(uintptr_t) + 2);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int fmt_handle_uint(struct ringbuf *buf, unsigned int u)
|
||||
{
|
||||
int ret;
|
||||
char str[PRINTK_UINT_BUFSZ];
|
||||
char *pos = &str[PRINTK_UINT_BUFSZ - 1];
|
||||
|
||||
do {
|
||||
/* stupid big endian humans, forcing us to do the whole thing in reverse */
|
||||
*pos-- = (char)(u % 10) + '0'; /* convert to ASCII */
|
||||
u /= 10;
|
||||
} while (u != 0);
|
||||
pos++;
|
||||
|
||||
ret = ringbuf_write(buf, pos, PRINTK_UINT_BUFSZ - (pos - &str[0]));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline int fmt_handle_int(struct ringbuf *buf, int i)
|
||||
{
|
||||
int ret = 0;
|
||||
char minus = '-';
|
||||
|
||||
if (i < 0) {
|
||||
ret = ringbuf_write(buf, &minus, sizeof(minus));
|
||||
i = -i;
|
||||
}
|
||||
|
||||
ret += fmt_handle_uint(buf, i);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a formatting escape sequence, fetch the parameter from the `va_arg`
|
||||
* stack, and print the resulting string to the standard serial console.
|
||||
*
|
||||
* @param pos: A reference to the pointer to the fmt sequence beginner (`%`).
|
||||
* This is updated to point to the first character *after* the entire
|
||||
* escape sequence.
|
||||
* @param args: A pointer to the varargs list. Will be manipulated.
|
||||
* @returns The amount of bytes written, or a negative POSIX error code.
|
||||
*/
|
||||
static inline int fmt_handle(struct ringbuf *buf, const char **pos, va_list args)
|
||||
{
|
||||
int ret = 0;
|
||||
union {
|
||||
int c;
|
||||
int d;
|
||||
uintptr_t p;
|
||||
char *s;
|
||||
unsigned int u;
|
||||
} val;
|
||||
|
||||
switch (**pos) {
|
||||
case '%': /* literal percent sign */
|
||||
ret = ringbuf_write(buf, *pos, sizeof(**pos));
|
||||
break;
|
||||
|
||||
case 'c': /* char */
|
||||
val.c = va_arg(args, typeof(val.c));
|
||||
ret = ringbuf_write(buf, &val.c, sizeof(val.c));
|
||||
break;
|
||||
|
||||
case 'd': /* int */
|
||||
val.d = va_arg(args, typeof(val.d));
|
||||
ret = fmt_handle_int(buf, val.d);
|
||||
break;
|
||||
|
||||
case 'p': /* ptr */
|
||||
val.p = va_arg(args, typeof(val.p));
|
||||
ret = fmt_handle_ptr(buf, val.p);
|
||||
break;
|
||||
|
||||
case 's': /* string */
|
||||
val.s = va_arg(args, typeof(val.s));
|
||||
ret = (int)strlen(val.s);
|
||||
ret = ringbuf_write(buf, val.s, (size_t)ret);
|
||||
break;
|
||||
|
||||
case 'u': /* unsigned int */
|
||||
val.u = va_arg(args, typeof(val.u));
|
||||
ret = fmt_handle_uint(buf, val.u);
|
||||
break;
|
||||
}
|
||||
|
||||
(*pos)++;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int printk(const char *fmt, ...)
|
||||
{
|
||||
va_list args;
|
||||
int ret = 0;
|
||||
int tmpret;
|
||||
const char *tmp = fmt;
|
||||
struct ringbuf *buf = ringbuf_create(CONFIG_PRINTK_BUFSZ);
|
||||
|
||||
if (buf == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
va_start(args, fmt);
|
||||
|
||||
while (*tmp != '\0') {
|
||||
if (*tmp++ == '%') {
|
||||
/* flush out everything we have so far (minus one char for %) */
|
||||
ret += (int)ringbuf_write(buf, fmt, (size_t)tmp - (size_t)fmt - 1);
|
||||
|
||||
tmpret = fmt_handle(buf, &tmp, args);
|
||||
/*
|
||||
* act as if the current position were the beginning in
|
||||
* order to make the first step of this if block easier
|
||||
*/
|
||||
fmt = tmp;
|
||||
|
||||
if (tmpret < 0)
|
||||
break;
|
||||
ret += tmpret;
|
||||
}
|
||||
}
|
||||
|
||||
if (tmp != fmt && ret >= 0)
|
||||
ret += ringbuf_write(buf, fmt, (size_t)tmp - (size_t)fmt);
|
||||
|
||||
va_end(args);
|
||||
|
||||
printk_flush(buf);
|
||||
ringbuf_destroy(buf);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* This file is part of Ardix.
|
||||
* Copyright (c) 2020, 2021 Felix Kopp <owo@fef.moe>.
|
||||
*
|
||||
* Ardix is non-violent software: you may only use, redistribute,
|
||||
* and/or modify it under the terms of the CNPLv6+ as found in
|
||||
* the LICENSE file in the source code root directory or at
|
||||
* <https://git.pixie.town/thufie/CNPL>.
|
||||
*
|
||||
* Ardix comes with ABSOLUTELY NO WARRANTY, to the extent
|
||||
* permitted by applicable law. See the CNPLv6+ for details.
|
||||
*/
|
||||
@ -0,0 +1,289 @@
|
||||
/* See the end of this file for copyright, license, and warranty information. */
|
||||
|
||||
#include <ardix/malloc.h>
|
||||
|
||||
#include <errno.h>
|
||||
/* Using GCC's stdarg.h is recommended even with -nodefaultlibs and -fno-builtin */
|
||||
#include <stdarg.h>
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <unistd.h>
|
||||
|
||||
#include <config.h>
|
||||
#include <toolchain.h>
|
||||
|
||||
#if __SIZEOF_INT__ == 2
|
||||
/* 5 decimal digits of 65535 (2 ** 16 - 1) */
|
||||
# define PRINTF_UINT_BUFSZ 5
|
||||
#elif __SIZEOF_INT__ == 4
|
||||
/* 10 decimal digits of 4294967295 (2 ** 32 - 1) */
|
||||
# define PRINTF_UINT_BUFSZ 10
|
||||
#else
|
||||
/* 20 decimal digits of 18446744073709551616 (2 ** 64 - 1) */
|
||||
# define PRINTF_UINT_BUFSZ 20
|
||||
#endif
|
||||
|
||||
struct printf_buf {
|
||||
size_t len;
|
||||
int fd;
|
||||
uint8_t data[0];
|
||||
};
|
||||
|
||||
static struct printf_buf *printf_buf_create(int fd)
|
||||
{
|
||||
struct printf_buf *buf = malloc(sizeof(*buf) + CONFIG_PRINTF_BUFSZ);
|
||||
|
||||
if (buf != NULL) {
|
||||
buf->len = 0;
|
||||
buf->fd = fd;
|
||||
}
|
||||
|
||||
return buf;
|
||||
}
|
||||
|
||||
static void printf_buf_destroy(struct printf_buf *buf)
|
||||
{
|
||||
if (buf->len != 0)
|
||||
write(buf->fd, &buf->data[0], buf->len);
|
||||
|
||||
free(buf);
|
||||
}
|
||||
|
||||
static ssize_t printf_buf_write(struct printf_buf *buf, const void *data, size_t len)
|
||||
{
|
||||
ssize_t ret = 0;
|
||||
const uint8_t *tmp = data;
|
||||
|
||||
while (ret != (ssize_t)len) {
|
||||
if (buf->len == CONFIG_PRINTF_BUFSZ) {
|
||||
/*
|
||||
* TODO: We don't need to take the syscall detour
|
||||
* if we are already in kernel context
|
||||
*/
|
||||
ssize_t write_ret = write(buf->fd, &buf->data[0], buf->len);
|
||||
if (write_ret < 0) {
|
||||
ret = write_ret;
|
||||
break;
|
||||
}
|
||||
|
||||
if (write_ret == 0) {
|
||||
/*
|
||||
* assume something has failed spectacularly
|
||||
* if write() didn't even write a single byte
|
||||
*/
|
||||
ret = -EIO;
|
||||
break;
|
||||
}
|
||||
|
||||
if (write_ret != (ssize_t)buf->len)
|
||||
memmove(&buf->data[0], &buf->data[write_ret], buf->len - write_ret);
|
||||
|
||||
buf->len -= write_ret;
|
||||
}
|
||||
|
||||
buf->data[buf->len++] = *tmp++;
|
||||
ret++;
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int fmt_handle_ptr(struct printf_buf *buf, uintptr_t ptr)
|
||||
{
|
||||
static const char fmt_hex_table[] = {
|
||||
'0', '1', '2', '3',
|
||||
'4', '5', '6', '7',
|
||||
'8', '9', 'a', 'b',
|
||||
'c', 'd', 'e', 'f',
|
||||
};
|
||||
|
||||
int ret;
|
||||
/* 2 chars per byte, plus 2 for the "0x" hex prefix */
|
||||
char str[2 * sizeof(uintptr_t) + 2];
|
||||
char *pos = &str[2 * sizeof(uintptr_t) + 1];
|
||||
|
||||
str[0] = '0';
|
||||
str[1] = 'x';
|
||||
|
||||
do {
|
||||
*pos-- = fmt_hex_table[ptr & 0xf];
|
||||
ptr >>= 4;
|
||||
} while (pos != &str[2]);
|
||||
|
||||
ret = printf_buf_write(buf, &str[0], 2 * sizeof(uintptr_t) + 2);
|
||||
return ret;
|
||||
}
|
||||
|
||||
static int fmt_handle_uint(struct printf_buf *buf, unsigned int u)
|
||||
{
|
||||
int ret;
|
||||
char str[PRINTF_UINT_BUFSZ];
|
||||
char *pos = &str[PRINTF_UINT_BUFSZ - 1];
|
||||
|
||||
do {
|
||||
/* stupid big endian humans, forcing us to do the whole thing in reverse */
|
||||
*pos-- = (char)(u % 10) + '0'; /* convert to ASCII */
|
||||
u /= 10;
|
||||
} while (u != 0);
|
||||
pos++;
|
||||
|
||||
ret = printf_buf_write(buf, pos, PRINTF_UINT_BUFSZ - (pos - &str[0]));
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline int fmt_handle_int(struct printf_buf *buf, int i)
|
||||
{
|
||||
int ret = 0;
|
||||
char minus = '-';
|
||||
|
||||
if (i < 0) {
|
||||
ret = printf_buf_write(buf, &minus, sizeof(minus));
|
||||
i = -i;
|
||||
}
|
||||
|
||||
ret += fmt_handle_uint(buf, i);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a formatting escape sequence, fetch the parameter from the `va_arg`
|
||||
* stack, and print the resulting string to the standard serial console.
|
||||
*
|
||||
* @param pos: A reference to the pointer to the fmt sequence beginner (`%`).
|
||||
* This is updated to point to the first character *after* the entire
|
||||
* escape sequence.
|
||||
* @param args: A pointer to the varargs list. Will be manipulated.
|
||||
* @returns The amount of bytes written, or a negative POSIX error code.
|
||||
*/
|
||||
static inline int fmt_handle(struct printf_buf *buf, const char **pos, va_list args)
|
||||
{
|
||||
int ret = 0;
|
||||
union {
|
||||
int c;
|
||||
int d;
|
||||
uintptr_t p;
|
||||
char *s;
|
||||
unsigned int u;
|
||||
} val;
|
||||
|
||||
switch (**pos) {
|
||||
case '%': /* literal percent sign */
|
||||
ret = printf_buf_write(buf, *pos, sizeof(**pos));
|
||||
break;
|
||||
|
||||
case 'c': /* char */
|
||||
val.c = va_arg(args, typeof(val.c));
|
||||
ret = printf_buf_write(buf, &val.c, sizeof(val.c));
|
||||
break;
|
||||
|
||||
case 'd': /* int */
|
||||
val.d = va_arg(args, typeof(val.d));
|
||||
ret = fmt_handle_int(buf, val.d);
|
||||
break;
|
||||
|
||||
case 'p': /* ptr */
|
||||
val.p = va_arg(args, typeof(val.p));
|
||||
ret = fmt_handle_ptr(buf, val.p);
|
||||
break;
|
||||
|
||||
case 's': /* string */
|
||||
val.s = va_arg(args, typeof(val.s));
|
||||
ret = (int)strlen(val.s);
|
||||
ret = printf_buf_write(buf, val.s, (size_t)ret);
|
||||
break;
|
||||
|
||||
case 'u': /* unsigned int */
|
||||
val.u = va_arg(args, typeof(val.u));
|
||||
ret = fmt_handle_uint(buf, val.u);
|
||||
break;
|
||||
}
|
||||
|
||||
(*pos)++;
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int vfprintf(FILE *f, const char *fmt, va_list args)
|
||||
{
|
||||
ssize_t ret = 0;
|
||||
const char *tmp = fmt;
|
||||
struct printf_buf *buf = printf_buf_create(_file_to_fd(f));
|
||||
|
||||
if (buf == NULL)
|
||||
return -ENOMEM;
|
||||
|
||||
while (*tmp != '\0') {
|
||||
if (*tmp++ == '%') {
|
||||
/* flush out everything we have so far (minus one char for %) */
|
||||
ssize_t tmpret = printf_buf_write(buf, fmt, (size_t)tmp - (size_t)fmt - 1);
|
||||
if (tmpret < 0) {
|
||||
ret = tmpret;
|
||||
break;
|
||||
}
|
||||
ret += tmpret;
|
||||
|
||||
tmpret = fmt_handle(buf, &tmp, args);
|
||||
/*
|
||||
* act as if the current position were the beginning in
|
||||
* order to make the first step of this if block easier
|
||||
*/
|
||||
fmt = tmp;
|
||||
|
||||
if (tmpret < 0)
|
||||
break;
|
||||
ret += tmpret;
|
||||
}
|
||||
}
|
||||
|
||||
if (tmp != fmt && ret >= 0)
|
||||
ret += printf_buf_write(buf, fmt, (size_t)tmp - (size_t)fmt);
|
||||
|
||||
printf_buf_destroy(buf);
|
||||
|
||||
return (int)ret;
|
||||
}
|
||||
|
||||
int vprintf(const char *fmt, va_list args)
|
||||
{
|
||||
return vfprintf(stdout, fmt, args);
|
||||
}
|
||||
|
||||
int fprintf(FILE *f, const char *fmt, ...)
|
||||
{
|
||||
int ret;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
ret = vfprintf(f, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
int printf(const char *fmt, ...)
|
||||
{
|
||||
int ret;
|
||||
va_list args;
|
||||
|
||||
va_start(args, fmt);
|
||||
ret = vfprintf(stdout, fmt, args);
|
||||
va_end(args);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
/*
|
||||
* This file is part of Ardix.
|
||||
* Copyright (c) 2020, 2021 Felix Kopp <owo@fef.moe>.
|
||||
*
|
||||
* Ardix is non-violent software: you may only use, redistribute,
|
||||
* and/or modify it under the terms of the CNPLv6+ as found in
|
||||
* the LICENSE file in the source code root directory or at
|
||||
* <https://git.pixie.town/thufie/CNPL>.
|
||||
*
|
||||
* Ardix comes with ABSOLUTELY NO WARRANTY, to the extent
|
||||
* permitted by applicable law. See the CNPLv6+ for details.
|
||||
*/
|
||||
Loading…
Reference in New Issue