kamkow1/my-os-project2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP 2

Browse Source
This commit is contained in:
Kamil Kowalczyk
2025-09-27 15:16:26 +02:00
parent 5af7c5276a
commit 3b1bb9d531
63 changed files with 1087 additions and 407 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
user/arch/x86_64/link.ld
View File

@ -1,7 +1,7 @@
ENTRY(_start)
SECTIONS {
. = 0x400000;
. = 0x1000;
.text ALIGN(4K):
{
@ -22,6 +22,7 @@ SECTIONS {
{
_bss_start = .;
*(.bss .bss*)
. = ALIGN(4K);
_bss_end = .;
}
}

3
user/init/main.c
View File

@ -21,8 +21,7 @@ void main(void) {
tb_runinitscript();
uprintf("Shell exited! Please reboot the system.\n");
writefmt("Shell exited! Please reboot the system.\n");
for(;;);
}

2
user/pctl/ls.c
View File

@ -66,7 +66,7 @@ void pctl_ls(void) {
uprintf("%-30s %s %-6s %-15s %-8s\n", "NAME", "PID", "TYPE", "MEMORY", "STATE");
for (size_t i = 0; i < procslen; i++) {
ProcStat stat = ZERO(&stat);
ProcStat stat; ZERO(&stat);
string_memset(namebuf, 0, 34);
string_memset(membuf, 0, 20);

399
user/tb/interp.c
View File

@ -9,183 +9,199 @@ extern uint64_t PID;
static InterpResult RES;
void tz_init(Tokenizer *tz, const char *str, size_t len) {
void tz_init(Tokenizer *tz, char *str) {
tz->str = str;
tz->len = len;
tz->pos = 0;
tz->tokens = NULL;
}
void tz_free(Tokenizer *tz) {
Token *tk = tz->tokens;
while (tk) {
Token *tmp = tk;
tk = tk->next;
dlfree(tmp);
Token *tk, *tktmp;
LL_FOREACH_SAFE(tz->tokens, tk, tktmp) {
dlfree(tk);
}
tz->tokens = NULL;
}
int tz_next(Tokenizer *tz, Token *out) {
while (tz->pos < tz->len && string_chr_isspace(tz->str[tz->pos])) {
tz->pos++;
}
#define TZ_MAX_TK 1024
if (tz->pos >= tz->len) {
return 0;
}
size_t start = tz->pos;
if (tz->str[start] == '"') {
start++;
tz->pos++;
while (tz->pos < tz->len && tz->str[tz->pos] != '"') {
tz->pos++;
}
if (tz->pos >= tz->len) {
out->ptr = tz->str + start;
out->len = tz->len - start;
tz->pos = tz->len;
void tz_tokenize(Tokenizer *tz) {
size_t len = string_len(tz->str);
for (size_t i = 0; i < len; i++) {
if (tz->str[i] == '\'') {
char *str = dlmalloc(TZ_MAX_TK);
string_memset(str, 0, TZ_MAX_TK);
i++;
size_t j = 0;
while (i < len && tz->str[i] != '\'') {
str[j++] = tz->str[i++];
}
Token *tk = dlmalloc(sizeof(*tk));
tk->str = str;
tk->next = NULL;
LL_APPEND(tz->tokens, tk);
} else {
out->ptr = tz->str + start;
out->len = tz->pos - start;
tz->pos++;
}
} else {
while (tz->pos < tz->len && !string_chr_isspace(tz->str[tz->pos])) {
tz->pos++;
}
out->ptr = tz->str + start;
out->len = tz->pos - start;
}
return 1;
}
void tz_classify(Tokenizer *tz) {
const int tmpbufsz = 256;
char *tmpbuf = dlmalloc(tmpbufsz);
Token *tk = tz->tokens;
while (tk) {
if (tk->ptr[0] == '"' && tk->ptr[tk->len - 1] == '"') {
tk->type = TOK_STRING;
} else if (tk->ptr[0] == '%') {
RtCmd *cmd = RTCMDS;
while (cmd) {
string_memset(tmpbuf, 0, tmpbufsz);
usnprintf(tmpbuf, tmpbufsz, "%.*s", (int)tk->len, tk->ptr);
if (string_strcmp(tmpbuf, cmd->cmdname) == 0) {
tk->type = TOK_CMD;
tk->cmd = cmd;
break;
}
cmd = cmd->next;
char *tkstr = dlmalloc(TZ_MAX_TK);
string_memset(tkstr, 0, TZ_MAX_TK);
size_t j = 0;
while (i < len && !string_chr_isspace(tz->str[i])) {
tkstr[j++] = tz->str[i++];
}
} else {
tk->type = TOK_MISC;
Token *tk = dlmalloc(sizeof(*tk));
tk->str = tkstr;
tk->next = NULL;
LL_APPEND(tz->tokens, tk);
}
tk = tk->next;
}
dlfree(tmpbuf);
}
void tz_expandspecial(Tokenizer *tz) {
Token *tk = tz->tokens;
while (tk) {
if (tk->ptr[0] == '$' && tk->len > 1) {
char *aliasbuf = dlmalloc(RTALIAS_NAMEBUF_MAX);
usnprintf(aliasbuf, RTALIAS_NAMEBUF_MAX, "%.*s", (int)tk->len-1, &tk->ptr[1]);
RtAlias *alias = RTALIASES;
while (alias) {
if (string_strcmp(alias->namebuf, aliasbuf) == 0) {
tk->ptr = alias->valbuf;
tk->len = string_len(alias->valbuf);
break;
}
alias = alias->next;
}
dlfree(aliasbuf);
}
tk = tk->next;
}
}
bool interp_readline(char *data, const char **bgptr, const char **endptr) {
static char *nextstart;
if (data) {
nextstart = data;
return true;
}
/* void tz_classify(Tokenizer *tz) { */
/* const int tmpbufsz = 256; */
/* char *tmpbuf = dlmalloc(tmpbufsz); */
if (*nextstart == '\0') {
return false;
}
*bgptr = nextstart;
const char *scn = nextstart;
/* Token *tk, *tktmp; */
/* LL_FOREACH_SAFE(tz->tokens, tk, tktmp) { */
/* if (tk->ptr[0] == '"' && tk->ptr[tk->len - 1] == '"') { */
/* tk->type = TOK_STRING; */
/* } else if (tk->ptr[0] == '%') { */
/* RtCmd *cmd, *cmdtmp; */
/* LL_FOREACH_SAFE(RTCMDS, cmd, cmdtmp) { */
/* string_memset(tmpbuf, 0, tmpbufsz); */
/* string_memcpy(tmpbuf, tk->ptr, MIN(tk->len, tmpbufsz)); */
/* if (string_strcmp(tmpbuf, cmd->cmdname) == 0) { */
/* tk->type = TOK_CMD; */
/* tk->cmd = cmd; */
/* break; */
/* } */
/* } */
/* } else { */
/* tk->type = TOK_MISC; */
/* } */
/* } */
/* dlfree(tmpbuf); */
/* } */
for (;;) {
while (*scn != '\0' && *scn != '\n') {
scn++;
}
if (*scn == '\n') {
if (scn > *bgptr && *(scn - 1) == '\\') {
scn--;
nextstart = scn;
*nextstart = ' ';
scn++;
if (*scn == '\n') {
scn++;
}
nextstart = scn;
continue;
}
}
break;
}
/* void tz_expandspecial(Tokenizer *tz) { */
/* Token *tk, *tktmp; */
/* LL_FOREACH_SAFE(tz->tokens, tk, tktmp) { */
/* if (tk->ptr[0] == '$' && tk->len > 1) { */
/* char aliasbuf[RTALIAS_NAMEBUF_MAX]; */
/* string_memset(aliasbuf, 0, sizeof(aliasbuf)); */
/* string_memcpy(aliasbuf, &tk->ptr[1], MIN(tk->len - 1, RTALIAS_NAMEBUF_MAX)); */
/* RtAlias *alias, *aliastmp; */
/* LL_FOREACH_SAFE(RTALIASES, alias, aliastmp) { */
/* if (string_strcmp(alias->namebuf, aliasbuf) == 0) { */
/* tk->ptr = alias->valbuf; */
/* tk->len = string_len(alias->valbuf); */
/* break; */
/* } */
/* } */
/* } */
/* } */
/* } */
*endptr = scn - 1;
while (string_chr_isspace(**bgptr) && *bgptr < *endptr) {
(*bgptr)++;
}
#define LINE_MAX 1024
while (string_chr_isspace(**endptr) && *endptr >= *bgptr) {
(*endptr)--;
}
(*endptr)++;
if (*scn == '\n') {
scn++;
}
nextstart = scn;
return true;
}
bool interp_runstring(const char *string, InterpResult **res, bool logcmds, bool interactive) {
bool interp_runstring(char *string, InterpResult **res, bool logcmds, bool interactive) {
*res = &RES;
string_memset(RES.errmsg, 0, sizeof(RES.errmsg));
rt_init();
bool ok = true;
const char *bg, *end;
interp_readline((char *)string, NULL, NULL);
while (interp_readline(NULL, &bg, &end)) {
size_t linelen = end - bg;
char *line = string_tokenizealloc(string, "\n");
while (line != NULL) {
if (logcmds) {
uprintf("+ %.*s\n", (int)linelen, bg);
writefmt("+{s}\n", line);
}
Tokenizer tz = {0};
tz_init(&tz, bg, linelen);
Tokenizer tz; ZERO(&tz);
tz_init(&tz, line);
tz_tokenize(&tz);
/* Token tktmp; ZERO(&tktmp); */
/* while (tz_next(&tz, &tktmp)) { */
/* Token *tk = dlmalloc(sizeof(*tk)); */
/* tk->ptr = tktmp.ptr; */
/* tk->len = tktmp.len; */
/* LL_APPEND(tz.tokens, tk); */
/* } */
/* tz_classify(&tz); */
/* tz_expandspecial(&tz); */
/* dlfree((void *)line); */
line = string_tokenizealloc(NULL, "\n");
}
#if 0
char line[LINE_MAX];
size_t pos = 0;
while (string[pos] != '\0') {
string_memset(line, 0, sizeof(line));
size_t next = inter_readline(string, pos, line, sizeof(line));
if (next == pos) {
break;
}
if (logcmds) {
uprintf("+%s\n", line);
}
/* Tokenizer tz; ZERO(&tz); */
/* tz_init(&tz, line, string_len(line)); */
/* Token tktmp; ZERO(&tktmp); */
/* while (tz_next(&tz, &tktmp)) { */
/* Token *tk = dlmalloc(sizeof(*tk)); */
/* tk->ptr = tktmp.ptr; */
/* tk->len = tktmp.len; */
/* tk->next = NULL; */
/* LL_APPEND(tz.tokens, tk); */
/* } */
/* tz_classify(&tz); */
/* tz_expandspecial(&tz); */
/* Token *cmdtk = tz.tokens; */
/* if (cmdtk->type == TOK_CMD) { */
/* ok = cmdtk->cmd->fn(cmdtk->next); */
/* if (!ok) { */
/* usprintf(RES.errmsg, "cmd %.*s failed", (int)cmdtk->len, cmdtk->ptr); */
/* tz_free(&tz); */
/* goto done; */
/* } */
/* } else if (cmdtk->type == TOK_MISC) { */
/* } */
/* nextline: { */
/* tz_free(&tz); */
pos = next;
/* } */
}
/* char *bg = NULL, *end = NULL; */
/* interp_readline((char *)string, NULL, NULL); */
/* while (interp_readline(NULL, &bg, &end)) { */
/* size_t linelen = (size_t)(end - bg); */
/* if (logcmds) { */
/* uprintf("+ %.*s\n", (int)linelen, bg); */
/* } */
/* Tokenizer tz = {0}; */
/* tz_init(&tz, bg, linelen); */
Token toktmp = {0};
/* Token toktmp = {0}; */
#if 0
while (tz_next(&tz, &toktmp)) {
Token *tok = dlmalloc(sizeof(*tok));
tok->ptr = toktmp.ptr;
tok->len = toktmp.len;
tok->next = NULL;
LL_APPEND(tz.tokens, tok);
string_memset(&toktmp, 0, sizeof(toktmp));
}
tz_classify(&tz);
@ -193,67 +209,62 @@ bool interp_runstring(const char *string, InterpResult **res, bool logcmds, bool
Token *cmdtk = tz.tokens;
if (cmdtk->type == TOK_CMD) {
ok = cmdtk->cmd->fn(cmdtk->next);
if (!ok) {
ok = false;
usprintf(RES.errmsg, "cmd %.*s failed", (int)cmdtk->len, cmdtk->ptr);
tz_free(&tz);
goto done;
}
/* ok = cmdtk->cmd->fn(cmdtk->next); */
/* if (!ok) { */
/* usprintf(RES.errmsg, "cmd %.*s failed", (int)cmdtk->len, cmdtk->ptr); */
/* tz_free(&tz); */
/* goto done; */
/* } */
} else if (cmdtk->type == TOK_MISC) {
char *appname = dlmalloc(1024);
usprintf(appname, "%.*s", (int)cmdtk->len, cmdtk->ptr);
/* const int appname_max = 128; */
/* char *appname = dlmalloc(appname_max); */
/* string_memset(appname, 0, appname_max); */
/* string_memcpy(appname, cmdtk->ptr, MIN(cmdtk->len, appname_max)); */
/* usnprintf(appname, appname_max, "%.*s", (int)cmdtk->len, cmdtk->ptr); */
size_t argslen1 = 0;
Token *argtk = cmdtk->next;
while (argtk) {
argslen1++;
argtk = argtk->next;
}
/* size_t argslen1; */
/* LL_FOREACH_SAFE_IDX(cmdtk->next, argtk, argtktmp, argslen1); */
char **args1 = (char **)dlmalloc(sizeof(char *) * argslen1);
argtk = cmdtk->next;
size_t i = 0;
while (argtk) {
args1[i] = (char *)dlmalloc(PROC_ARG_MAX);
string_memset(args1[i], 0, PROC_ARG_MAX);
string_memcpy(args1[i], argtk->ptr, argtk->len);
i++;
argtk = argtk->next;
}
/* size_t i; */
/* char **args1 = (char **)dlmalloc(sizeof(char *) * argslen1); */
/* LL_FOREACH_SAFE_IDX(cmdtk->next, argtk, argtktmp, i) { */
/* args1[i] = (char *)dlmalloc(PROC_ARG_MAX); */
/* string_memset(args1[i], 0, PROC_ARG_MAX); */
/* string_memcpy(args1[i], argtk->ptr, argtk->len); */
/* } */
int32_t app = processctl(-1, PCTL_SPAWN, (uint64_t)appname, (uint64_t)args1, argslen1);
if (app < 0) {
usprintf(RES.errmsg, "Could not run %s: %s\n", appname, ERRSTRING(app));
ok = false;
goto cleanup;
}
/* int32_t app = processctl(-1, PCTL_SPAWN, (uint64_t)appname, (uint64_t)args1, argslen1); */
/* if (app < 0) { */
/* usprintf(RES.errmsg, "Could not run %s: %s\n", appname, ERRSTRING(app)); */
/* ok = false; */
/* goto cleanup; */
/* } */
processctl(app, PCTL_RUN, 0, 0, 0);
/* processctl(app, PCTL_RUN, 0, 0, 0); */
uint8_t b;
while(processctl(app, PCTL_POLLSTATE, 0, 0, 0) != 4) {
if (interactive) {
int32_t nrd = ipcpipe(PID, IPCPIPE_IN, IPCPIPE_READ, &b, 1);
if (nrd > 0 && b == C('S')) {
processctl(app, PCTL_KILL, 0, 0, 0);
goto cleanup;
}
}
schedrelease();
}
/* uint8_t b; */
/* while(processctl(app, PCTL_POLLSTATE, 0, 0, 0) != 4) { */
/* if (interactive) { */
/* int32_t nrd = ipcpipe(PID, IPCPIPE_IN, IPCPIPE_READ, &b, 1); */
/* if (nrd > 0 && b == C('S')) { */
/* processctl(app, PCTL_KILL, 0, 0, 0); */
/* goto cleanup; */
/* } */
/* } */
/* schedrelease(); */
/* } */
cleanup: {
for (size_t j = 0; j < argslen1; j++) {
dlfree(args1[j]);
}
dlfree(args1);
dlfree(appname);
/* for (size_t j = 0; j < argslen1; j++) dlfree(args1[j]); */
/* dlfree(args1); */
/* dlfree((void*)appname); */
}
}
tz_free(&tz);
}
#endif
/* } */
#endif
done:
return ok;
}

10
user/tb/interp.h
View File

@ -13,8 +13,7 @@ typedef struct {
typedef struct Token {
struct Token *next;
const char *ptr;
size_t len;
char *str;
enum {
TOK_STRING,
@ -26,13 +25,10 @@ typedef struct Token {
} Token;
typedef struct {
const char *str;
size_t len;
size_t pos;
char *str;
Token *tokens;
} Tokenizer;
bool interp_runstring(const char *string, InterpResult **res, bool logcmds, bool interactive);
bool interp_runstring(char *string, InterpResult **res, bool logcmds, bool interactive);
#endif // TB_INTERP_H_

40
user/tb/main.c
View File

@ -32,7 +32,7 @@ void do_file(char *filepath);
void set_config(void) {
int32_t ret;
if ((ret = parse_args(args(), argslen(), ARGS)) < 0) {
uprintf("Could not parse args: %d\n", ret);
writefmt("Could not parse args: {d}\n", ret);
}
if (CONFIG.modestr != NULL) {
@ -41,7 +41,7 @@ void set_config(void) {
} else if (string_strcmp(CONFIG.modestr, "runfile") == 0) {
CONFIG.mode = MODE_RUNFILE;
} else {
LOG(LOG_ERR, "Unknown mode %s\n", CONFIG.modestr);
LOG(LOG_ERR, "Unknown mode {s}\n", CONFIG.modestr);
}
} else {
CONFIG.mode = MODE_RUNFILE;
@ -53,7 +53,7 @@ void do_file(char *filepath) {
int32_t ioh = ioctl(IOCTL_NOHANDLE, IOCTL_OPENF, (uint64_t)filepath, IOCTL_F_READ, 0);
if (ioh < 0) {
LOG(LOG_ERR, "Could not open %s: %s\n", filepath, ERRSTRING(ioh));
LOG(LOG_ERR, "Could not open {s}: {s}\n", filepath, ERRSTRING(ioh));
return;
}
@ -61,27 +61,27 @@ void do_file(char *filepath) {
ioctl(ioh, IOCTL_STAT, (uint64_t)&statbuf, 0, 0);
if (statbuf.type != IOCTLSTAT_FILE) {
LOG(LOG_ERR, "%s is not a file (%d)\n", filepath, statbuf.type);
LOG(LOG_ERR, "{s} is not a file ({d})\n", filepath, statbuf.type);
return;
}
uint8_t *buf = dlmalloc(statbuf.size+1);
string_memset(buf, 0, statbuf.size+1);
if ((ret = ioctl(ioh, IOCTL_READ, (uint64_t)buf, statbuf.size, 0)) < 0) {
LOG(LOG_ERR, "Could not read %s (%d): %s\n", filepath, ioh, ERRSTRING(ioh));
LOG(LOG_ERR, "Could not read {s} ({d}): {s}\n", filepath, ioh, ERRSTRING(ioh));
goto done;
}
InterpResult *res;
bool ok = interp_runstring((const char *)buf, &res, CONFIG.logcmds, CONFIG.mode == MODE_INTERACTIVE);
bool ok = interp_runstring((char *)buf, &res, CONFIG.logcmds, CONFIG.mode == MODE_INTERACTIVE);
if (!ok) {
uprintf("Interpreter error:\n");
uprintf("%s\n", res->errmsg);
writefmt("Interpreter error:\n");
writefmt("{s}\n", res->errmsg);
goto done;
}
done:
dlfree(buf);
/* dlfree(buf); */
ioctl(ioh, IOCTL_CLOSEF, 0, 0, 0);
}
@ -90,7 +90,7 @@ void do_mode_interactive(void) {
size_t cursor;
for(;;) {
begin:
uprintf("tb# ");
writefmt("tb# ");
cursor = 0;
string_memset(linebuf, 0, LINEBUF_MAX);
@ -102,12 +102,12 @@ void do_mode_interactive(void) {
switch (b) {
case C('C'):
case 0xE9:
uprintf("\n");
writefmt("\n");
goto begin;
break;
case C('L'):
uprintf(ANSIQ_CUR_SET(0, 0));
uprintf(ANSIQ_SCR_CLR_ALL);
writefmt(ANSIQ_CUR_SET(0, 0));
writefmt(ANSIQ_SCR_CLR_ALL);
goto begin;
break;
}
@ -118,7 +118,7 @@ void do_mode_interactive(void) {
if (string_chr_isascii(b) && b != 0 && cursor < LINEBUF_MAX) {
linebuf[cursor++] = b;
uprintf("%c", b);
writefmt("{c}", b);
}
} else {
schedrelease();
@ -128,10 +128,10 @@ void do_mode_interactive(void) {
if (cursor < LINEBUF_MAX) {
linebuf[cursor] = '\0';
}
uprintf("\n");
writefmt("\n");
InterpResult *res;
if (!interp_runstring(linebuf, &res, CONFIG.logcmds, CONFIG.mode == MODE_INTERACTIVE)) {
LOG(LOG_ERR, "%s\n", res->errmsg);
LOG(LOG_ERR, "{s}\n", res->errmsg);
}
}
}
@ -140,17 +140,17 @@ void main(void) {
PID = processctl(-1, PCTL_GETPID, 0, 0, 0);
set_config();
if (CONFIG.preloadpath != NULL) {
LOG(LOG_INF, "Preloading script: %s\n", CONFIG.preloadpath);
LOG(LOG_INF, "Preloading script: {s}\n", CONFIG.preloadpath);
do_file(CONFIG.preloadpath);
}
if (CONFIG.mode == MODE_INTERACTIVE) {
do_mode_interactive();
/* do_mode_interactive(); */
} else if (CONFIG.mode == MODE_RUNFILE) {
if (CONFIG.filepath == NULL) {
uprintf("No file provided\n");
writefmt("No file provided\n");
return;
}
do_file(CONFIG.filepath);

25
user/tb/runtime.c
View File

@ -16,32 +16,31 @@ RtAlias *RTALIASES = NULL;
} while(0)
bool rt_print(Token *tks) {
Token *tk = tks;
while (tk) {
uprintf("%.*s", (int)tk->len, tk->ptr);
Token *tk, *tktmp;
LL_FOREACH_SAFE(tks, tk, tktmp) {
writefmt("{s}", tk->str);
if (tk->next != NULL) {
uprintf(" ");
writefmt(" ");
}
tk = tk->next;
}
uprintf("\n");
writefmt("\n");
return true;
}
bool rt_mkalias(Token *tks) {
RtAlias *alias = dlmalloc(sizeof(*alias));
string_memset(alias, 0, sizeof(*alias));
Token *tk = tks;
size_t i = 0;
while (tk) {
size_t i;
Token *tk, *tktmp;
LL_FOREACH_SAFE_IDX(tks, tk, tktmp, i) {
if (i == 0) {
usprintf(alias->namebuf, "%.*s", (int)tk->len, tk->ptr);
string_memcpy(alias->namebuf, tk->str, MIN(string_len(tk->str), RTALIAS_NAMEBUF_MAX));
} else if (i == 1) {
usprintf(alias->valbuf, "%.*s", (int)tk->len, tk->ptr);
string_memcpy(alias->valbuf, tk->str, MIN(string_len(tk->str), RTALIAS_VALBUF_MAX));
}
i++;
tk = tk->next;
}
LL_APPEND(RTALIASES, alias);
return true;
}