fix: update template, prevent double-spaced persisted kernel logs
This commit is contained in:
@@ -1,7 +1,8 @@
|
||||
/*
|
||||
* config.h
|
||||
* Config file manager for MontaukOS programs
|
||||
* Loads, modifies, and saves TOML config files from 0:/config/
|
||||
* Loads, modifies, and saves TOML config files from 0:/config/ and
|
||||
* 0:/users/<name>/config/, and reads OS data tables from 0:/os/data/
|
||||
* Copyright (c) 2026 Daniel Hammer
|
||||
*/
|
||||
|
||||
@@ -187,29 +188,13 @@ namespace config {
|
||||
// ---- File operations ----
|
||||
|
||||
// Ensure the config directory exists
|
||||
inline void ensure_dir() {
|
||||
montauk::fmkdir(CONFIG_DIR);
|
||||
}
|
||||
|
||||
// Build full path: "0:/config/<name>.toml"
|
||||
inline void build_path(char* out, int outSz, const char* name) {
|
||||
int p = 0;
|
||||
const char* dir = CONFIG_DIR;
|
||||
while (*dir && p < outSz - 2) out[p++] = *dir++;
|
||||
out[p++] = '/';
|
||||
while (*name && p < outSz - 6) out[p++] = *name++;
|
||||
// Append ".toml"
|
||||
const char* ext = ".toml";
|
||||
while (*ext && p < outSz - 1) out[p++] = *ext++;
|
||||
out[p] = '\0';
|
||||
}
|
||||
|
||||
// Load a config file by name (without extension).
|
||||
// Returns an initialized Doc (empty if file doesn't exist).
|
||||
inline toml::Doc load(const char* name) {
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
// ---- Shared file I/O (absolute path in, Doc out) ----
|
||||
// Only the path builders below know where each class of file lives. These
|
||||
// two do the actual work for system config, per-user config and OS data.
|
||||
|
||||
// Read and parse a TOML file at an absolute path.
|
||||
// Returns an initialized Doc (empty if the file is missing or empty).
|
||||
inline toml::Doc load_path(const char* path) {
|
||||
int handle = montauk::open(path);
|
||||
if (handle < 0) {
|
||||
toml::Doc doc;
|
||||
@@ -235,15 +220,9 @@ namespace config {
|
||||
return doc;
|
||||
}
|
||||
|
||||
// Save a Doc to disk as a TOML file.
|
||||
// Creates the file if it doesn't exist.
|
||||
// Returns 0 on success, negative on error.
|
||||
inline int save(const char* name, toml::Doc* doc) {
|
||||
ensure_dir();
|
||||
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
|
||||
// Serialize a Doc and write it to an absolute path. The caller creates the
|
||||
// parent directory. Returns 0 on success, negative on error.
|
||||
inline int save_path(const char* path, toml::Doc* doc) {
|
||||
char* text = serialize(doc);
|
||||
int textLen = montauk::slen(text);
|
||||
|
||||
@@ -262,6 +241,42 @@ namespace config {
|
||||
return ret < 0 ? ret : 0;
|
||||
}
|
||||
|
||||
inline void ensure_dir() {
|
||||
montauk::fmkdir(CONFIG_DIR);
|
||||
}
|
||||
|
||||
// Build full path: "0:/config/<name>.toml"
|
||||
inline void build_path(char* out, int outSz, const char* name) {
|
||||
int p = 0;
|
||||
const char* dir = CONFIG_DIR;
|
||||
while (*dir && p < outSz - 2) out[p++] = *dir++;
|
||||
out[p++] = '/';
|
||||
while (*name && p < outSz - 6) out[p++] = *name++;
|
||||
// Append ".toml"
|
||||
const char* ext = ".toml";
|
||||
while (*ext && p < outSz - 1) out[p++] = *ext++;
|
||||
out[p] = '\0';
|
||||
}
|
||||
|
||||
// Load a config file by name (without extension).
|
||||
// Returns an initialized Doc (empty if file doesn't exist).
|
||||
inline toml::Doc load(const char* name) {
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
return load_path(path);
|
||||
}
|
||||
|
||||
// Save a Doc to disk as a TOML file.
|
||||
// Creates the file if it doesn't exist.
|
||||
// Returns 0 on success, negative on error.
|
||||
inline int save(const char* name, toml::Doc* doc) {
|
||||
ensure_dir();
|
||||
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
return save_path(path, doc);
|
||||
}
|
||||
|
||||
// ---- Per-user config ----
|
||||
|
||||
// Build path: "0:/users/<username>/config/<name>.toml"
|
||||
@@ -298,30 +313,7 @@ namespace config {
|
||||
inline toml::Doc load_user(const char* username, const char* name) {
|
||||
char path[192];
|
||||
build_user_path(path, sizeof(path), username, name);
|
||||
|
||||
int handle = montauk::open(path);
|
||||
if (handle < 0) {
|
||||
toml::Doc doc;
|
||||
doc.init();
|
||||
return doc;
|
||||
}
|
||||
|
||||
uint64_t size = montauk::getsize(handle);
|
||||
if (size == 0) {
|
||||
montauk::close(handle);
|
||||
toml::Doc doc;
|
||||
doc.init();
|
||||
return doc;
|
||||
}
|
||||
|
||||
char* text = (char*)montauk::malloc(size + 1);
|
||||
montauk::read(handle, (uint8_t*)text, 0, size);
|
||||
montauk::close(handle);
|
||||
text[size] = '\0';
|
||||
|
||||
toml::Doc doc = toml::parse(text);
|
||||
montauk::mfree(text);
|
||||
return doc;
|
||||
return load_path(path);
|
||||
}
|
||||
|
||||
// Save a per-user config file
|
||||
@@ -330,21 +322,7 @@ namespace config {
|
||||
|
||||
char path[192];
|
||||
build_user_path(path, sizeof(path), username, name);
|
||||
|
||||
char* text = serialize(doc);
|
||||
int textLen = montauk::slen(text);
|
||||
|
||||
montauk::fdelete(path);
|
||||
int handle = montauk::fcreate(path);
|
||||
if (handle < 0) {
|
||||
montauk::mfree(text);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int ret = montauk::fwrite(handle, (const uint8_t*)text, 0, textLen);
|
||||
montauk::close(handle);
|
||||
montauk::mfree(text);
|
||||
return ret < 0 ? ret : 0;
|
||||
return save_path(path, doc);
|
||||
}
|
||||
|
||||
// Delete a config file. Returns 0 on success.
|
||||
@@ -426,4 +404,36 @@ namespace config {
|
||||
}
|
||||
|
||||
} // namespace config
|
||||
|
||||
// ---- Read-only OS data tables ----
|
||||
// Reference data that ships with the OS and is never written back: keyboard
|
||||
// layouts, time zone tables and the like. This lives under 0:/os because it is
|
||||
// OS payload, not configuration -- 0:/config is for state a user or admin
|
||||
// edits. There is deliberately no save() here, so the read-only nature of the
|
||||
// directory is enforced by the API rather than by convention.
|
||||
namespace data {
|
||||
|
||||
static constexpr const char* DATA_DIR = "0:/os/data";
|
||||
|
||||
// Build full path: "0:/os/data/<name>.toml"
|
||||
inline void build_path(char* out, int outSz, const char* name) {
|
||||
int p = 0;
|
||||
const char* dir = DATA_DIR;
|
||||
while (*dir && p < outSz - 2) out[p++] = *dir++;
|
||||
out[p++] = '/';
|
||||
while (*name && p < outSz - 6) out[p++] = *name++;
|
||||
const char* ext = ".toml";
|
||||
while (*ext && p < outSz - 1) out[p++] = *ext++;
|
||||
out[p] = '\0';
|
||||
}
|
||||
|
||||
// Load an OS data table by name (without extension).
|
||||
// Returns an initialized Doc (empty if the file is missing).
|
||||
inline toml::Doc load(const char* name) {
|
||||
char path[128];
|
||||
build_path(path, sizeof(path), name);
|
||||
return config::load_path(path);
|
||||
}
|
||||
|
||||
} // namespace data
|
||||
} // namespace montauk
|
||||
|
||||
@@ -1,290 +1,39 @@
|
||||
/*
|
||||
* heap.h
|
||||
* Userspace heap allocator for MontaukOS programs
|
||||
* Copyright (c) 2025 Daniel Hammer
|
||||
* Unified userspace heap API for MontaukOS programs
|
||||
* Copyright (c) 2025-2026 Daniel Hammer
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
#include <montauk/syscall.h>
|
||||
#include <montauk/string.h>
|
||||
#include <cstddef>
|
||||
#include <cstdint>
|
||||
|
||||
// The allocator lives in libc. Keeping these declarations here lets
|
||||
// freestanding C++ programs use the Montauk API without pulling in all of
|
||||
// <stdlib.h>, while ensuring C, C++, and libraries share one heap.
|
||||
extern "C" {
|
||||
void* malloc(std::size_t size);
|
||||
void free(void* ptr);
|
||||
void* realloc(void* ptr, std::size_t size);
|
||||
void* calloc(std::size_t count, std::size_t size);
|
||||
}
|
||||
|
||||
namespace montauk {
|
||||
namespace heap_detail {
|
||||
|
||||
static constexpr uint64_t HEADER_MAGIC = 0x5A484541; // "ZHEA"
|
||||
static constexpr uint64_t FREED_MAGIC = 0xDEADFEEE;
|
||||
|
||||
struct Header {
|
||||
uint64_t magic;
|
||||
uint64_t size; // user-requested size
|
||||
} __attribute__((packed));
|
||||
|
||||
struct FreeNode {
|
||||
uint64_t size; // total size of this free block (including node)
|
||||
FreeNode* next;
|
||||
};
|
||||
|
||||
// Segregated free lists: power-of-2 size classes for blocks <= 4096 bytes.
|
||||
// Blocks larger than 4096 go to the overflow list.
|
||||
static constexpr int NUM_BUCKETS = 8;
|
||||
static constexpr uint64_t BUCKET_SIZES[NUM_BUCKETS] = {
|
||||
32, 64, 128, 256, 512, 1024, 2048, 4096
|
||||
};
|
||||
|
||||
// Per-process heap state — must be `inline` (not `static`) so that all
|
||||
// translation units in a multi-TU program share a single heap.
|
||||
inline FreeNode* g_buckets[NUM_BUCKETS] = {};
|
||||
inline FreeNode g_overflow{0, nullptr};
|
||||
inline bool g_initialized = false;
|
||||
|
||||
// Process-wide heap lock. Userspace threads share the heap, so the
|
||||
// public malloc/mfree/realloc entry points must serialize access to
|
||||
// g_buckets/g_overflow. Kept inline here (not in thread.h) because
|
||||
// thread.h depends on heap.h, and the internal helpers below are not
|
||||
// reentrant into the public API, so a plain spinlock suffices.
|
||||
inline volatile uint32_t g_heap_lock = 0;
|
||||
|
||||
static inline void heap_lock_acquire() {
|
||||
while (__atomic_exchange_n(&g_heap_lock, 1, __ATOMIC_ACQUIRE) != 0) {
|
||||
syscall0(montauk::abi::SYS_YIELD);
|
||||
}
|
||||
}
|
||||
static inline void heap_lock_release() {
|
||||
__atomic_store_n(&g_heap_lock, 0, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
static inline Header* get_header(void* block) {
|
||||
return (Header*)((uint8_t*)block - sizeof(Header));
|
||||
}
|
||||
|
||||
// Determine which bucket a block size belongs to, or -1 for overflow
|
||||
static inline int bucket_index(uint64_t blockSize) {
|
||||
if (blockSize <= 32) return 0;
|
||||
if (blockSize <= 64) return 1;
|
||||
if (blockSize <= 128) return 2;
|
||||
if (blockSize <= 256) return 3;
|
||||
if (blockSize <= 512) return 4;
|
||||
if (blockSize <= 1024) return 5;
|
||||
if (blockSize <= 2048) return 6;
|
||||
if (blockSize <= 4096) return 7;
|
||||
return -1;
|
||||
}
|
||||
|
||||
// Insert into overflow list (sorted by address, with adjacent-block coalescing)
|
||||
static inline void insert_overflow(void* ptr, uint64_t size) {
|
||||
auto* node = (FreeNode*)ptr;
|
||||
node->size = size;
|
||||
|
||||
FreeNode* prev = &g_overflow;
|
||||
FreeNode* cur = g_overflow.next;
|
||||
while (cur != nullptr && cur < node) {
|
||||
prev = cur;
|
||||
cur = cur->next;
|
||||
}
|
||||
|
||||
bool merged_prev = false;
|
||||
if (prev != &g_overflow &&
|
||||
(uint8_t*)prev + prev->size == (uint8_t*)node) {
|
||||
prev->size += size;
|
||||
node = prev;
|
||||
merged_prev = true;
|
||||
}
|
||||
|
||||
if (cur != nullptr &&
|
||||
(uint8_t*)node + node->size == (uint8_t*)cur) {
|
||||
node->size += cur->size;
|
||||
node->next = cur->next;
|
||||
if (!merged_prev) prev->next = node;
|
||||
} else if (!merged_prev) {
|
||||
node->next = cur;
|
||||
prev->next = node;
|
||||
}
|
||||
}
|
||||
|
||||
// Take a block of at least `needed` bytes from the overflow list.
|
||||
// Splits remainder back into overflow if worthwhile.
|
||||
static inline void* take_from_overflow(uint64_t needed) {
|
||||
FreeNode* prev = &g_overflow;
|
||||
FreeNode* cur = g_overflow.next;
|
||||
|
||||
while (cur != nullptr) {
|
||||
if (cur->size >= needed) {
|
||||
uint64_t blockSize = cur->size;
|
||||
prev->next = cur->next;
|
||||
|
||||
if (blockSize > needed + sizeof(FreeNode) + 16) {
|
||||
insert_overflow((uint8_t*)cur + needed, blockSize - needed);
|
||||
}
|
||||
return (void*)cur;
|
||||
}
|
||||
prev = cur;
|
||||
cur = cur->next;
|
||||
}
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
// Next slab size for heap growth. The kernel tracks a finite number
|
||||
// of SYS_ALLOC records per process (MaxHeapAllocs), so growing once
|
||||
// per large allocation exhausts them under allocation-heavy loads
|
||||
// (the native ld ran out mid-link). Doubling slabs keep the syscall
|
||||
// count logarithmic in total heap size.
|
||||
inline uint64_t g_grow_slab = 16 * 0x1000;
|
||||
|
||||
static inline bool grow(uint64_t bytes) {
|
||||
uint64_t want = (bytes + 0xFFF) & ~0xFFFULL;
|
||||
if (want < 0x4000) want = 0x4000;
|
||||
|
||||
uint64_t slab = (want > g_grow_slab) ? want : g_grow_slab;
|
||||
if (g_grow_slab < 4 * 1024 * 1024) g_grow_slab *= 2;
|
||||
|
||||
void* mem = montauk::alloc(slab);
|
||||
if (mem == nullptr && slab > want) {
|
||||
// Big slab refused (low memory): retry with the exact need.
|
||||
slab = want;
|
||||
mem = montauk::alloc(slab);
|
||||
}
|
||||
if (mem == nullptr) return false;
|
||||
insert_overflow(mem, slab);
|
||||
return true;
|
||||
}
|
||||
|
||||
// Refill a small-block bucket by carving a page-sized chunk from overflow
|
||||
static inline bool refill_bucket(int idx) {
|
||||
uint64_t bsize = BUCKET_SIZES[idx];
|
||||
uint64_t chunk = (bsize < 4096) ? 4096 : bsize;
|
||||
|
||||
void* block = take_from_overflow(chunk);
|
||||
if (block == nullptr) {
|
||||
if (!grow(chunk)) return false;
|
||||
block = take_from_overflow(chunk);
|
||||
if (block == nullptr) return false;
|
||||
}
|
||||
|
||||
uint64_t count = chunk / bsize;
|
||||
for (uint64_t i = 0; i < count; i++) {
|
||||
auto* node = (FreeNode*)((uint8_t*)block + i * bsize);
|
||||
node->size = bsize;
|
||||
node->next = g_buckets[idx];
|
||||
g_buckets[idx] = node;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
} // namespace heap_detail
|
||||
|
||||
// ---- Public API ----
|
||||
|
||||
inline void* malloc(uint64_t size) {
|
||||
using namespace heap_detail;
|
||||
|
||||
// Guard against overflow: size + Header must not wrap
|
||||
if (size > UINT64_MAX - sizeof(Header) - 15)
|
||||
return nullptr;
|
||||
|
||||
heap_lock_acquire();
|
||||
|
||||
if (!g_initialized) {
|
||||
grow(16 * 0x1000); // seed with 64 KiB
|
||||
g_initialized = true;
|
||||
}
|
||||
|
||||
uint64_t needed = size + sizeof(Header);
|
||||
needed = (needed + 15) & ~15ULL;
|
||||
|
||||
int idx = bucket_index(needed);
|
||||
|
||||
if (idx >= 0) {
|
||||
// Small allocation — use segregated bucket (O(1))
|
||||
if (g_buckets[idx] == nullptr && !refill_bucket(idx)) {
|
||||
heap_lock_release();
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
FreeNode* node = g_buckets[idx];
|
||||
g_buckets[idx] = node->next;
|
||||
|
||||
Header* header = (Header*)node;
|
||||
header->magic = HEADER_MAGIC;
|
||||
header->size = size;
|
||||
heap_lock_release();
|
||||
return (void*)((uint8_t*)header + sizeof(Header));
|
||||
}
|
||||
|
||||
// Large allocation — search overflow list
|
||||
void* block = take_from_overflow(needed);
|
||||
if (block == nullptr) {
|
||||
if (!grow(needed)) { heap_lock_release(); return nullptr; }
|
||||
block = take_from_overflow(needed);
|
||||
if (block == nullptr) { heap_lock_release(); return nullptr; }
|
||||
}
|
||||
|
||||
Header* header = (Header*)block;
|
||||
header->magic = HEADER_MAGIC;
|
||||
header->size = size;
|
||||
heap_lock_release();
|
||||
return (void*)((uint8_t*)header + sizeof(Header));
|
||||
return ::malloc((std::size_t)size);
|
||||
}
|
||||
|
||||
inline void mfree(void* ptr) {
|
||||
using namespace heap_detail;
|
||||
|
||||
if (ptr == nullptr) return;
|
||||
|
||||
Header* header = get_header(ptr);
|
||||
|
||||
heap_lock_acquire();
|
||||
|
||||
if (header->magic == FREED_MAGIC) { heap_lock_release(); return; } // double-free
|
||||
if (header->magic != HEADER_MAGIC) { heap_lock_release(); return; } // corrupt
|
||||
header->magic = FREED_MAGIC;
|
||||
|
||||
uint64_t blockSize = header->size + sizeof(Header);
|
||||
blockSize = (blockSize + 15) & ~15ULL;
|
||||
|
||||
int idx = bucket_index(blockSize);
|
||||
|
||||
if (idx >= 0) {
|
||||
// Small block — push onto bucket (O(1))
|
||||
auto* node = (FreeNode*)header;
|
||||
node->size = BUCKET_SIZES[idx];
|
||||
node->next = g_buckets[idx];
|
||||
g_buckets[idx] = node;
|
||||
} else {
|
||||
// Large block — sorted insert with coalescing
|
||||
insert_overflow((void*)header, blockSize);
|
||||
}
|
||||
heap_lock_release();
|
||||
::free(ptr);
|
||||
}
|
||||
|
||||
inline void* realloc(void* ptr, uint64_t size) {
|
||||
if (ptr == nullptr) return malloc(size);
|
||||
return ::realloc(ptr, (std::size_t)size);
|
||||
}
|
||||
|
||||
// Read old size under the lock to avoid racing with another
|
||||
// thread that might be freeing/recycling this header.
|
||||
heap_detail::heap_lock_acquire();
|
||||
auto* header = heap_detail::get_header(ptr);
|
||||
uint64_t old = header->size;
|
||||
|
||||
uint64_t oldBlock = (old + sizeof(heap_detail::Header) + 15) & ~15ULL;
|
||||
int idx = heap_detail::bucket_index(oldBlock);
|
||||
if (idx >= 0) oldBlock = heap_detail::BUCKET_SIZES[idx];
|
||||
|
||||
uint64_t newNeed = (size + sizeof(heap_detail::Header) + 15) & ~15ULL;
|
||||
if (newNeed <= oldBlock) {
|
||||
header->size = size;
|
||||
heap_detail::heap_lock_release();
|
||||
return ptr;
|
||||
}
|
||||
heap_detail::heap_lock_release();
|
||||
|
||||
void* newBlock = malloc(size);
|
||||
if (newBlock == nullptr) return nullptr;
|
||||
|
||||
uint64_t copySize = (old < size) ? old : size;
|
||||
memcpy(newBlock, ptr, copySize);
|
||||
|
||||
mfree(ptr);
|
||||
return newBlock;
|
||||
inline void* calloc(uint64_t count, uint64_t size) {
|
||||
return ::calloc((std::size_t)count, (std::size_t)size);
|
||||
}
|
||||
|
||||
} // namespace montauk
|
||||
|
||||
@@ -0,0 +1,326 @@
|
||||
/*
|
||||
* keyboard.h
|
||||
* Keyboard layout registry, per-user selection, and scan-code translation
|
||||
* Copyright (c) 2026 Daniel Hammer
|
||||
*/
|
||||
|
||||
#pragma once
|
||||
|
||||
#include <montauk/config.h>
|
||||
#include <montauk/string.h>
|
||||
|
||||
namespace montauk::keyboard {
|
||||
|
||||
inline constexpr int MAX_LAYOUTS = 8;
|
||||
inline constexpr int MAX_KEYS = 64;
|
||||
|
||||
// One overridden key. Characters are Windows-1252 bytes to match the
|
||||
// single-byte GUI text stack; 0 means "no override, keep the kernel's value".
|
||||
struct KeyMap {
|
||||
uint8_t scancode;
|
||||
uint8_t base;
|
||||
uint8_t shift;
|
||||
uint8_t altgr;
|
||||
};
|
||||
|
||||
struct Layout {
|
||||
char id[8];
|
||||
char name[48];
|
||||
char short_name[8];
|
||||
KeyMap keys[MAX_KEYS];
|
||||
int key_count; // 0 = passthrough (the kernel's US table)
|
||||
};
|
||||
|
||||
struct Registry {
|
||||
Layout items[MAX_LAYOUTS];
|
||||
int count;
|
||||
};
|
||||
|
||||
struct State {
|
||||
Registry registry;
|
||||
bool enabled[MAX_LAYOUTS];
|
||||
int active;
|
||||
};
|
||||
|
||||
inline void build_key(char* out, int cap, const char* prefix,
|
||||
const char* id, const char* suffix = nullptr) {
|
||||
int pos = 0;
|
||||
const char* parts[3] = {prefix, id, suffix};
|
||||
for (int part = 0; part < 3; part++) {
|
||||
const char* text = parts[part];
|
||||
if (!text) continue;
|
||||
while (*text && pos < cap - 1) out[pos++] = *text++;
|
||||
}
|
||||
out[pos] = '\0';
|
||||
}
|
||||
|
||||
// Read an array of byte values from the layout table.
|
||||
// Returns the element count, or -1 if the key is missing or malformed.
|
||||
inline int read_bytes(const toml::Doc& doc, const char* key,
|
||||
uint8_t* out, int cap) {
|
||||
toml::Value* arr = doc.get_array(key);
|
||||
if (!arr) return -1;
|
||||
if (arr->array.count > cap) return -1;
|
||||
for (int i = 0; i < arr->array.count; i++) {
|
||||
toml::Value* value = arr->array.items[i];
|
||||
if (!value || value->type != toml::Type::Int) return -1;
|
||||
if (value->ival < 0 || value->ival > 0xFF) return -1;
|
||||
out[i] = (uint8_t)value->ival;
|
||||
}
|
||||
return arr->array.count;
|
||||
}
|
||||
|
||||
// Parse one [layouts.<id>] table. Returns false if the layout declares key
|
||||
// overrides but they are inconsistent, in which case the caller skips it: a
|
||||
// malformed table must never produce a half-applied layout.
|
||||
inline bool load_layout(Layout* out, const char* id, const toml::Doc& doc) {
|
||||
if (!out) return false;
|
||||
*out = {};
|
||||
montauk::strncpy(out->id, id, sizeof(out->id));
|
||||
|
||||
char key[64];
|
||||
build_key(key, sizeof(key), "layouts.", id, ".name");
|
||||
montauk::strncpy(out->name, doc.get_string(key, id), sizeof(out->name));
|
||||
build_key(key, sizeof(key), "layouts.", id, ".short_name");
|
||||
montauk::strncpy(out->short_name, doc.get_string(key, id),
|
||||
sizeof(out->short_name));
|
||||
|
||||
uint8_t scancodes[MAX_KEYS];
|
||||
uint8_t base[MAX_KEYS];
|
||||
uint8_t shift[MAX_KEYS];
|
||||
uint8_t altgr[MAX_KEYS] = {};
|
||||
|
||||
build_key(key, sizeof(key), "layouts.", id, ".scancodes");
|
||||
int count = read_bytes(doc, key, scancodes, MAX_KEYS);
|
||||
if (count < 0) {
|
||||
// No override table at all: a passthrough layout such as "en".
|
||||
out->key_count = 0;
|
||||
return true;
|
||||
}
|
||||
|
||||
build_key(key, sizeof(key), "layouts.", id, ".base");
|
||||
if (read_bytes(doc, key, base, MAX_KEYS) != count) return false;
|
||||
build_key(key, sizeof(key), "layouts.", id, ".shift");
|
||||
if (read_bytes(doc, key, shift, MAX_KEYS) != count) return false;
|
||||
build_key(key, sizeof(key), "layouts.", id, ".altgr");
|
||||
int altgr_count = read_bytes(doc, key, altgr, MAX_KEYS);
|
||||
if (altgr_count >= 0 && altgr_count != count) return false;
|
||||
|
||||
for (int i = 0; i < count; i++) {
|
||||
out->keys[i].scancode = scancodes[i];
|
||||
out->keys[i].base = base[i];
|
||||
out->keys[i].shift = shift[i];
|
||||
out->keys[i].altgr = altgr[i];
|
||||
}
|
||||
out->key_count = count;
|
||||
return true;
|
||||
}
|
||||
|
||||
// The compiled-in base layout. The kernel's scancode table is already US
|
||||
// English, so this overrides nothing; it exists so the registry is never
|
||||
// empty and input keeps working even with no data file on disk.
|
||||
inline void add_base_layout(Registry* registry) {
|
||||
if (!registry || registry->count >= MAX_LAYOUTS) return;
|
||||
Layout& layout = registry->items[registry->count++];
|
||||
layout = {};
|
||||
montauk::strcpy(layout.id, "en");
|
||||
montauk::strcpy(layout.name, "English (US)");
|
||||
montauk::strcpy(layout.short_name, "en");
|
||||
layout.key_count = 0;
|
||||
}
|
||||
|
||||
inline int find_layout(const Registry& registry, const char* id) {
|
||||
for (int i = 0; i < registry.count; i++)
|
||||
if (montauk::streq(registry.items[i].id, id)) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
inline Registry load_registry() {
|
||||
Registry registry = {};
|
||||
toml::Doc doc = montauk::data::load("keyboard-layouts");
|
||||
|
||||
toml::Value* order = doc.get_array("registry.layouts");
|
||||
if (order) {
|
||||
for (int i = 0; i < order->array.count; i++) {
|
||||
toml::Value* value = order->array.items[i];
|
||||
if (!value || value->type != toml::Type::String || !value->str)
|
||||
continue;
|
||||
if (registry.count >= MAX_LAYOUTS) break;
|
||||
if (find_layout(registry, value->str) >= 0) continue;
|
||||
Layout candidate;
|
||||
if (!load_layout(&candidate, value->str, doc)) continue;
|
||||
registry.items[registry.count++] = candidate;
|
||||
}
|
||||
}
|
||||
doc.destroy();
|
||||
|
||||
// Guarantee a working layout even if the data file is missing, malformed,
|
||||
// or simply omits "en".
|
||||
if (find_layout(registry, "en") < 0) {
|
||||
if (registry.count >= MAX_LAYOUTS) registry.count = MAX_LAYOUTS - 1;
|
||||
for (int i = registry.count; i > 0; i--)
|
||||
registry.items[i] = registry.items[i - 1];
|
||||
registry.count++;
|
||||
Registry base = {};
|
||||
add_base_layout(&base);
|
||||
registry.items[0] = base.items[0];
|
||||
}
|
||||
return registry;
|
||||
}
|
||||
|
||||
// Re-read only the user's selection, leaving the registry alone. The registry
|
||||
// is read-only OS data that cannot change while the machine is running, so
|
||||
// callers polling for layout changes should use this rather than load_user:
|
||||
// it reads one small file instead of re-parsing the whole layout table.
|
||||
inline void refresh_selection(State* state, const char* username) {
|
||||
if (!state) return;
|
||||
for (int i = 0; i < state->registry.count; i++) state->enabled[i] = false;
|
||||
|
||||
toml::Doc doc = config::load_user(username, "keyboard");
|
||||
for (int i = 0; i < state->registry.count; i++) {
|
||||
char key[48];
|
||||
build_key(key, sizeof(key), "layouts.", state->registry.items[i].id);
|
||||
state->enabled[i] = doc.get_bool(key, i == 0);
|
||||
}
|
||||
const char* active_id = doc.get_string("selection.active", "en");
|
||||
state->active = find_layout(state->registry, active_id);
|
||||
doc.destroy();
|
||||
|
||||
if (state->registry.count == 0) return;
|
||||
if (state->active < 0 || !state->enabled[state->active]) {
|
||||
state->active = 0;
|
||||
while (state->active < state->registry.count
|
||||
&& !state->enabled[state->active])
|
||||
state->active++;
|
||||
}
|
||||
if (state->active >= state->registry.count) {
|
||||
state->active = 0;
|
||||
state->enabled[0] = true;
|
||||
}
|
||||
}
|
||||
|
||||
inline State load_user(const char* username) {
|
||||
State state = {};
|
||||
state.registry = load_registry();
|
||||
refresh_selection(&state, username);
|
||||
return state;
|
||||
}
|
||||
|
||||
inline bool save_user(const char* username, const State& state) {
|
||||
toml::Doc doc;
|
||||
doc.init();
|
||||
for (int i = 0; i < state.registry.count; i++) {
|
||||
char key[48];
|
||||
build_key(key, sizeof(key), "layouts.", state.registry.items[i].id);
|
||||
config::set_bool(&doc, key, state.enabled[i]);
|
||||
}
|
||||
int active = state.active >= 0 && state.active < state.registry.count
|
||||
? state.active : 0;
|
||||
config::set_string(&doc, "selection.active", state.registry.items[active].id);
|
||||
int result = config::save_user(username, "keyboard", &doc);
|
||||
doc.destroy();
|
||||
return result == 0;
|
||||
}
|
||||
|
||||
// NOTE: layouts are per-user by design. The login screen runs before there is
|
||||
// a user, so it stays US-English until it grows its own layout switcher; there
|
||||
// is deliberately no machine-wide "current layout" for it to read, because a
|
||||
// wrong guess there is unrecoverable (you cannot type your password to fix it).
|
||||
|
||||
inline int next_enabled(const State& state, int current) {
|
||||
if (state.registry.count <= 0) return 0;
|
||||
for (int step = 1; step <= state.registry.count; step++) {
|
||||
int candidate = (current + step) % state.registry.count;
|
||||
if (state.enabled[candidate]) return candidate;
|
||||
}
|
||||
return current;
|
||||
}
|
||||
|
||||
// Caps Lock is derived rather than declared per key: it applies only where
|
||||
// base and shift are a Windows-1252 lower/upper letter pair. That covers the
|
||||
// accented letters (aa 0xE5 / AA 0xC5) without wrongly upper-casing keys such
|
||||
// as 2 / " where the shifted value is unrelated punctuation.
|
||||
inline constexpr bool is_letter_pair(uint8_t base, uint8_t shift) {
|
||||
if (base == 0 || shift == 0) return false;
|
||||
if (base < 0x61) return false;
|
||||
if (base > 0x7A && base < 0xE0) return false;
|
||||
if (base == 0xF7) return false; // division sign sits inside the range
|
||||
return shift == (uint8_t)(base - 0x20);
|
||||
}
|
||||
|
||||
static_assert(is_letter_pair(0xE5, 0xC5)); // aa / AA
|
||||
static_assert(is_letter_pair(0xF8, 0xD8)); // oe / OE
|
||||
static_assert(is_letter_pair(0xE6, 0xC6)); // ae / AE
|
||||
static_assert(is_letter_pair('a', 'A'));
|
||||
static_assert(!is_letter_pair('2', '"'));
|
||||
static_assert(!is_letter_pair(0xF7, 0xD7)); // divide / multiply
|
||||
|
||||
inline void translate(const State& state, abi::KeyEvent* key) {
|
||||
if (!key) return;
|
||||
if (state.active < 0 || state.active >= state.registry.count) return;
|
||||
const Layout& layout = state.registry.items[state.active];
|
||||
|
||||
// Extended keys carry a main-block scancode with the E0 prefix stripped
|
||||
// (keypad "/" arrives as 0x35, the same as the main "/"), so translating
|
||||
// them would turn keypad "/" into whatever the layout puts on that key.
|
||||
if (key->extended) return;
|
||||
|
||||
uint8_t scancode = key->scancode & 0x7F;
|
||||
for (int i = 0; i < layout.key_count; i++) {
|
||||
const KeyMap& mapping = layout.keys[i];
|
||||
if (mapping.scancode != scancode) continue;
|
||||
|
||||
uint8_t out;
|
||||
if (key->altgr) {
|
||||
out = mapping.altgr;
|
||||
} else {
|
||||
bool upper = key->shift;
|
||||
if (is_letter_pair(mapping.base, mapping.shift))
|
||||
upper = key->shift != key->capslock;
|
||||
out = upper ? mapping.shift : mapping.base;
|
||||
}
|
||||
if (out != 0) {
|
||||
key->ascii = (char)out;
|
||||
// An AltGr key that produced a character is text, not a shortcut.
|
||||
// Apps gate insertion on !alt (and alt is LeftAlt||RightAlt), so
|
||||
// leaving it set would silently swallow every AltGr character.
|
||||
if (key->altgr) key->alt = false;
|
||||
}
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// ---- Direct keyboard readers ----
|
||||
// The desktop translates events before routing them to windows, but programs
|
||||
// that read the kernel buffer themselves (terminal, login) never pass through
|
||||
// it and would otherwise always get the US layout. They translate through this
|
||||
// instead. The registry is parsed once; only the small per-user selection file
|
||||
// is re-read, at most once a second, so switching layout in the panel reaches
|
||||
// them shortly afterwards without re-parsing the whole layout table.
|
||||
|
||||
struct DirectInput {
|
||||
State state;
|
||||
bool loaded;
|
||||
uint64_t last_poll;
|
||||
};
|
||||
|
||||
inline DirectInput& direct_input() {
|
||||
static DirectInput input; // zero-initialised POD, so no guard variable
|
||||
return input;
|
||||
}
|
||||
|
||||
inline void translate_direct(abi::KeyEvent* key, const char* username) {
|
||||
DirectInput& input = direct_input();
|
||||
uint64_t now = montauk::get_milliseconds();
|
||||
if (!input.loaded) {
|
||||
input.state = load_user(username);
|
||||
input.loaded = true;
|
||||
input.last_poll = now;
|
||||
} else if (now - input.last_poll >= 1000) {
|
||||
refresh_selection(&input.state, username);
|
||||
input.last_poll = now;
|
||||
}
|
||||
translate(input.state, key);
|
||||
}
|
||||
|
||||
} // namespace montauk::keyboard
|
||||
@@ -197,6 +197,8 @@ namespace montauk {
|
||||
inline bool is_key_available() { return (bool)syscall0(montauk::abi::SYS_ISKEYAVAILABLE); }
|
||||
inline void getkey(montauk::abi::KeyEvent* out) { syscall1(montauk::abi::SYS_GETKEY, (uint64_t)out); }
|
||||
inline char getchar() { return (char)syscall0(montauk::abi::SYS_GETCHAR); }
|
||||
// Returns 0 rather than blocking when no character is pending.
|
||||
inline char getchar_nb() { return (char)syscall0(montauk::abi::SYS_GETCHAR_NB); }
|
||||
inline uint64_t input_wait(uint64_t observedSerial, uint64_t timeoutMs) {
|
||||
return (uint64_t)syscall2(montauk::abi::SYS_INPUT_WAIT, observedSerial, timeoutMs);
|
||||
}
|
||||
@@ -432,6 +434,10 @@ namespace montauk {
|
||||
return syscall2(montauk::abi::SYS_LOG, (uint64_t)buf, size);
|
||||
}
|
||||
|
||||
inline int64_t write_log(const char* userspaceComponent, const char* logMessage) {
|
||||
return syscall2(montauk::abi::SYS_LOG_WRITE, (uint64_t)userspaceComponent, (uint64_t)logMessage);
|
||||
}
|
||||
|
||||
// I/O redirection
|
||||
inline int spawn_redir(const char* path, const char* args = nullptr) {
|
||||
return (int)syscall2(montauk::abi::SYS_SPAWN_REDIR, (uint64_t)path, (uint64_t)args);
|
||||
|
||||
@@ -44,8 +44,22 @@ namespace montauk {
|
||||
ThreadEntry user_entry;
|
||||
void* user_arg;
|
||||
void* stack_base;
|
||||
int tid;
|
||||
ThreadCtx* next;
|
||||
};
|
||||
|
||||
inline ThreadCtx* g_thread_records = nullptr;
|
||||
inline volatile uint32_t g_thread_records_lock = 0;
|
||||
|
||||
inline void records_lock() {
|
||||
while (__atomic_exchange_n(&g_thread_records_lock, 1, __ATOMIC_ACQUIRE) != 0)
|
||||
montauk::yield();
|
||||
}
|
||||
|
||||
inline void records_unlock() {
|
||||
__atomic_store_n(&g_thread_records_lock, 0, __ATOMIC_RELEASE);
|
||||
}
|
||||
|
||||
// Userspace trampoline: bridges from the raw entry the kernel jumps
|
||||
// to into the typed entry, then funnels into SYS_THREAD_EXIT. We
|
||||
// route the exit through libc rather than relying on a kernel-side
|
||||
@@ -53,21 +67,24 @@ namespace montauk {
|
||||
// memory on this path.
|
||||
//
|
||||
// The thread's stack itself is intentionally not freed here: we are
|
||||
// still running on it. It is reclaimed when the process exits, or
|
||||
// the joiner may free it explicitly after thread_join.
|
||||
// still running on it. It is reclaimed by a successful thread_join,
|
||||
// or as part of whole-process teardown if the thread is never joined.
|
||||
[[noreturn]] inline void thread_trampoline(detail::ThreadCtx* ctx) {
|
||||
// A sibling CPU can start the thread before thread_spawn has
|
||||
// returned its TID. Wait until the parent has published the record
|
||||
// needed by thread_join to reclaim this stack.
|
||||
while (__atomic_load_n(&ctx->tid, __ATOMIC_ACQUIRE) == 0)
|
||||
montauk::yield();
|
||||
int code = ctx->user_entry(ctx->user_arg);
|
||||
montauk::mfree(ctx);
|
||||
thread_exit(code);
|
||||
}
|
||||
}
|
||||
|
||||
// Spawn a new thread that begins executing `entry(arg)`. Returns the
|
||||
// new TID on success, or -1 on failure. The thread's stack is
|
||||
// allocated from the user heap; it is leaked on thread exit (the
|
||||
// thread itself cannot free the stack it is running on). The kernel
|
||||
// reclaims it on process exit. Callers that need to spawn many short-
|
||||
// lived threads should pool stacks themselves.
|
||||
// allocated from the user heap. The exiting thread cannot free the stack
|
||||
// it is running on, so thread_join reclaims both it and the trampoline
|
||||
// context after the kernel has reaped the sibling.
|
||||
inline int thread_spawn(ThreadEntry entry, void* arg,
|
||||
uint64_t stack_bytes = 0) {
|
||||
if (entry == nullptr) return -1;
|
||||
@@ -84,6 +101,8 @@ namespace montauk {
|
||||
ctx->user_entry = entry;
|
||||
ctx->user_arg = arg;
|
||||
ctx->stack_base = stack;
|
||||
ctx->tid = 0;
|
||||
ctx->next = nullptr;
|
||||
|
||||
uint64_t stack_top = ((uint64_t)stack + stack_bytes) & ~0xFULL;
|
||||
int tid = (int)syscall3(montauk::abi::SYS_THREAD_SPAWN,
|
||||
@@ -94,6 +113,11 @@ namespace montauk {
|
||||
montauk::mfree(stack);
|
||||
return -1;
|
||||
}
|
||||
detail::records_lock();
|
||||
ctx->next = detail::g_thread_records;
|
||||
detail::g_thread_records = ctx;
|
||||
__atomic_store_n(&ctx->tid, tid, __ATOMIC_RELEASE);
|
||||
detail::records_unlock();
|
||||
return tid;
|
||||
}
|
||||
|
||||
@@ -101,8 +125,22 @@ namespace montauk {
|
||||
// success (with the thread's exit code in *out_code if non-null) or
|
||||
// -1 if `tid` is not a joinable sibling.
|
||||
inline int thread_join(int tid, int* out_code = nullptr) {
|
||||
return (int)syscall2(montauk::abi::SYS_THREAD_JOIN,
|
||||
(uint64_t)tid, (uint64_t)out_code);
|
||||
int result = (int)syscall2(montauk::abi::SYS_THREAD_JOIN,
|
||||
(uint64_t)tid, (uint64_t)out_code);
|
||||
if (result == 0) {
|
||||
detail::records_lock();
|
||||
detail::ThreadCtx** link = &detail::g_thread_records;
|
||||
while (*link != nullptr && (*link)->tid != tid)
|
||||
link = &(*link)->next;
|
||||
detail::ThreadCtx* ctx = *link;
|
||||
if (ctx != nullptr) *link = ctx->next;
|
||||
detail::records_unlock();
|
||||
if (ctx != nullptr) {
|
||||
montauk::mfree(ctx->stack_base);
|
||||
montauk::mfree(ctx);
|
||||
}
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// Return the calling thread's TID (== getpid() for the main thread).
|
||||
|
||||
@@ -16,6 +16,12 @@
|
||||
* the kernel derives the PMK from it (or takes a 64-character hex string as
|
||||
* a raw PSK). Anyone who can read 0:/config can read the keys.
|
||||
*
|
||||
* No default copy of this file ships in the image, deliberately. Every other
|
||||
* config an app writes (bluetooth.toml, display.toml, session.toml) is
|
||||
* created on demand for the same reason: a shipped copy is laid down again
|
||||
* by anything that refreshes the system files, and it would overwrite the
|
||||
* networks the user had saved.
|
||||
*
|
||||
* Copyright (c) 2026 Daniel Hammer
|
||||
*/
|
||||
|
||||
|
||||
Reference in New Issue
Block a user