LeonMMcoset/cleonos
1
0
Fork 0
mirror of https://github.com/Leonmmcoset/cleonos.git synced 2026-04-24 11:14:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

chore: split kit into standalone submodule

Browse Source
This commit is contained in:
Leonmmcoset
2026-04-23 22:39:47 +08:00
parent 881b62b5d8
commit 48ce2aba66
26 changed files with 4 additions and 2901 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -10,3 +10,6 @@
[submodule "wine"]
path = wine
url = https://github.com/CLeonOS/wine
[submodule "kit"]
path = kit
url = https://github.com/CLeonOS/kit.git

1
kit Submodule

Submodule kit added at a8dfe5c4eb

3
kit/.gitignore vendored
View File

@@ -1,3 +0,0 @@
build/
build-cmake/
build-cmake-*/

234
kit/CMakeLists.txt
View File

@@ -1,234 +0,0 @@
cmake_minimum_required(VERSION 3.20)
project(CLeonOSKit NONE)
set(CLEONOS_KIT_APPS_DIR "${CMAKE_SOURCE_DIR}/apps" CACHE PATH "Directory containing app subdirectories")
set(CLEONOS_KIT_RUNTIME_DIR "${CMAKE_SOURCE_DIR}/runtime" CACHE PATH "Directory containing user runtime sources")
set(CLEONOS_KIT_INCLUDE_DIR "${CMAKE_SOURCE_DIR}/include" CACHE PATH "Directory containing user runtime headers")
set(CLEONOS_KIT_LINKER_SCRIPT "${CMAKE_SOURCE_DIR}/linker/user.ld" CACHE FILEPATH "Linker script for user ELF")
set(CLEONOS_KIT_OUTPUT_DIR "${CMAKE_SOURCE_DIR}/build/apps" CACHE PATH "Output directory for generated ELF files")
set(CLEONOS_KIT_OBJ_DIR "${CMAKE_SOURCE_DIR}/build/obj" CACHE PATH "Output directory for object files")
set(CLEONOS_KIT_APP_NAMES "" CACHE STRING "Optional app list, separated by comma/semicolon (empty means all apps)")
set(CLEONOS_KIT_USE_MAIN_ADAPTER ON CACHE BOOL "When ON, apps can provide plain main(int,char**)")
set(CLEONOS_KIT_ENABLE_WERROR ON CACHE BOOL "Treat warnings as errors")
set(CLEONOS_KIT_CC "x86_64-elf-gcc" CACHE STRING "C compiler for user ELF objects")
set(CLEONOS_KIT_LD "x86_64-elf-ld" CACHE STRING "Linker for user ELF")
function(resolve_tool_with_fallback VAR_NAME)
set(_fallbacks ${ARGN})
set(_requested "${${VAR_NAME}}")
if("${_requested}" STREQUAL "")
message(FATAL_ERROR "empty tool variable: ${VAR_NAME}")
endif()
if(IS_ABSOLUTE "${_requested}")
if(NOT EXISTS "${_requested}")
message(FATAL_ERROR "${VAR_NAME} not found: ${_requested}")
endif()
set(_resolved "${_requested}")
else()
unset(_requested_path CACHE)
unset(_requested_path)
find_program(_requested_path NAMES "${_requested}")
if(_requested_path)
set(_resolved "${_requested_path}")
else()
set(_resolved "")
foreach(_cand IN LISTS _fallbacks)
unset(_cand_path CACHE)
unset(_cand_path)
find_program(_cand_path NAMES "${_cand}")
if(_cand_path)
message(STATUS "${VAR_NAME} '${_requested}' not found; fallback to '${_cand}'")
set(_resolved "${_cand_path}")
break()
endif()
endforeach()
if("${_resolved}" STREQUAL "")
message(FATAL_ERROR "${VAR_NAME} tool not found: '${_requested}', fallbacks='${_fallbacks}'")
endif()
endif()
endif()
set(${VAR_NAME} "${_resolved}" CACHE STRING "resolved tool path" FORCE)
set(${VAR_NAME} "${_resolved}" PARENT_SCOPE)
endfunction()
resolve_tool_with_fallback(CLEONOS_KIT_CC gcc clang cc)
resolve_tool_with_fallback(CLEONOS_KIT_LD ld ld.lld)
execute_process(
COMMAND ${CLEONOS_KIT_LD} -V
RESULT_VARIABLE _ld_probe_rc
OUTPUT_VARIABLE _ld_probe_out
ERROR_VARIABLE _ld_probe_err
)
execute_process(
COMMAND ${CLEONOS_KIT_LD} --help
RESULT_VARIABLE _ld_help_rc
OUTPUT_VARIABLE _ld_help_out
ERROR_VARIABLE _ld_help_err
)
set(_ld_probe_text "${_ld_probe_out}\n${_ld_probe_err}\n${_ld_help_out}\n${_ld_help_err}")
string(TOLOWER "${_ld_probe_text}" _ld_probe_lower)
if(_ld_probe_lower MATCHES "i386pep"
OR _ld_probe_lower MATCHES "pei-"
OR _ld_probe_lower MATCHES "pe-coff"
OR _ld_probe_lower MATCHES "appcontainer"
OR _ld_probe_lower MATCHES "auto-import")
message(FATAL_ERROR
"selected linker appears to target PE/COFF, not ELF. "
"Use an ELF toolchain, for example: "
"-DCLEONOS_KIT_CC=x86_64-elf-gcc -DCLEONOS_KIT_LD=x86_64-elf-ld")
endif()
if(NOT EXISTS "${CLEONOS_KIT_LINKER_SCRIPT}")
message(FATAL_ERROR "missing linker script: ${CLEONOS_KIT_LINKER_SCRIPT}")
endif()
if(NOT IS_DIRECTORY "${CLEONOS_KIT_APPS_DIR}")
message(FATAL_ERROR "missing apps directory: ${CLEONOS_KIT_APPS_DIR}")
endif()
if(NOT IS_DIRECTORY "${CLEONOS_KIT_RUNTIME_DIR}")
message(FATAL_ERROR "missing runtime directory: ${CLEONOS_KIT_RUNTIME_DIR}")
endif()
if(NOT IS_DIRECTORY "${CLEONOS_KIT_INCLUDE_DIR}")
message(FATAL_ERROR "missing include directory: ${CLEONOS_KIT_INCLUDE_DIR}")
endif()
file(MAKE_DIRECTORY "${CLEONOS_KIT_OUTPUT_DIR}")
file(MAKE_DIRECTORY "${CLEONOS_KIT_OBJ_DIR}")
set(_runtime_sources
"${CLEONOS_KIT_RUNTIME_DIR}/runtime.c"
"${CLEONOS_KIT_RUNTIME_DIR}/syscall.c"
"${CLEONOS_KIT_RUNTIME_DIR}/stdio.c"
"${CLEONOS_KIT_RUNTIME_DIR}/libc_string.c"
"${CLEONOS_KIT_RUNTIME_DIR}/libc_stdlib.c"
"${CLEONOS_KIT_RUNTIME_DIR}/libc_ctype.c"
"${CLEONOS_KIT_RUNTIME_DIR}/dlfcn.c"
)
if(CLEONOS_KIT_USE_MAIN_ADAPTER)
list(APPEND _runtime_sources "${CLEONOS_KIT_RUNTIME_DIR}/main_adapter.c")
endif()
foreach(_src IN LISTS _runtime_sources)
if(NOT EXISTS "${_src}")
message(FATAL_ERROR "missing runtime source: ${_src}")
endif()
endforeach()
set(CLEONOS_KIT_CFLAGS
-std=c11
-ffreestanding
-fno-stack-protector
-fno-builtin
-Wall
-Wextra
-m64
-mno-red-zone
-fno-pic
-fno-pie
"-I${CLEONOS_KIT_INCLUDE_DIR}"
)
if(CLEONOS_KIT_ENABLE_WERROR)
list(APPEND CLEONOS_KIT_CFLAGS -Werror)
endif()
set(CLEONOS_KIT_LDFLAGS "" CACHE STRING "Extra linker flags (semicolon separated)")
function(cleonos_compile_object SRC_PATH OUT_VAR)
file(RELATIVE_PATH _rel "${CMAKE_SOURCE_DIR}" "${SRC_PATH}")
string(REGEX REPLACE "\\.c$" ".o" _obj_rel "${_rel}")
set(_obj_path "${CLEONOS_KIT_OBJ_DIR}/${_obj_rel}")
get_filename_component(_obj_dir "${_obj_path}" DIRECTORY)
add_custom_command(
OUTPUT "${_obj_path}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${_obj_dir}"
COMMAND ${CLEONOS_KIT_CC} ${CLEONOS_KIT_CFLAGS} -c "${SRC_PATH}" -o "${_obj_path}"
DEPENDS "${SRC_PATH}"
VERBATIM
)
set(${OUT_VAR} "${_obj_path}" PARENT_SCOPE)
endfunction()
function(cleonos_kit_add_app APP_NAME)
set(_app_sources ${ARGN})
if(NOT _app_sources)
message(FATAL_ERROR "cleonos_kit_add_app(${APP_NAME}) requires at least one source")
endif()
set(_obj_list)
foreach(_src IN LISTS _runtime_sources _app_sources)
cleonos_compile_object("${_src}" _obj)
list(APPEND _obj_list "${_obj}")
endforeach()
set(_out_path "${CLEONOS_KIT_OUTPUT_DIR}/${APP_NAME}.elf")
add_custom_command(
OUTPUT "${_out_path}"
COMMAND ${CMAKE_COMMAND} -E make_directory "${CLEONOS_KIT_OUTPUT_DIR}"
COMMAND ${CLEONOS_KIT_LD} ${CLEONOS_KIT_LDFLAGS} -T "${CLEONOS_KIT_LINKER_SCRIPT}" -o "${_out_path}" ${_obj_list}
DEPENDS ${_obj_list} "${CLEONOS_KIT_LINKER_SCRIPT}"
VERBATIM
)
add_custom_target("app-${APP_NAME}" DEPENDS "${_out_path}")
set_property(GLOBAL APPEND PROPERTY CLEONOS_KIT_APP_TARGETS "app-${APP_NAME}")
set_property(GLOBAL APPEND PROPERTY CLEONOS_KIT_APP_OUTPUTS "${_out_path}")
endfunction()
set(_app_names)
if("${CLEONOS_KIT_APP_NAMES}" STREQUAL "")
file(GLOB _app_entries RELATIVE "${CLEONOS_KIT_APPS_DIR}" "${CLEONOS_KIT_APPS_DIR}/*")
foreach(_entry IN LISTS _app_entries)
if(IS_DIRECTORY "${CLEONOS_KIT_APPS_DIR}/${_entry}")
list(APPEND _app_names "${_entry}")
endif()
endforeach()
else()
string(REPLACE "," ";" _app_names "${CLEONOS_KIT_APP_NAMES}")
endif()
list(REMOVE_DUPLICATES _app_names)
list(SORT _app_names)
if(NOT _app_names)
message(FATAL_ERROR "no apps selected/found under ${CLEONOS_KIT_APPS_DIR}")
endif()
foreach(_app IN LISTS _app_names)
if(NOT IS_DIRECTORY "${CLEONOS_KIT_APPS_DIR}/${_app}")
message(FATAL_ERROR "app directory not found: ${CLEONOS_KIT_APPS_DIR}/${_app}")
endif()
file(GLOB_RECURSE _app_sources CONFIGURE_DEPENDS "${CLEONOS_KIT_APPS_DIR}/${_app}/*.c")
if(NOT _app_sources)
message(FATAL_ERROR "no C sources found for app '${_app}' in ${CLEONOS_KIT_APPS_DIR}/${_app}")
endif()
cleonos_kit_add_app("${_app}" ${_app_sources})
endforeach()
get_property(_kit_targets GLOBAL PROPERTY CLEONOS_KIT_APP_TARGETS)
get_property(_kit_outputs GLOBAL PROPERTY CLEONOS_KIT_APP_OUTPUTS)
if(NOT _kit_targets)
message(FATAL_ERROR "no app targets were generated")
endif()
add_custom_target(apps ALL DEPENDS ${_kit_targets})
message(STATUS "CLeonOS kit apps: ${_app_names}")
message(STATUS "CLeonOS kit output: ${CLEONOS_KIT_OUTPUT_DIR}")

64
kit/Makefile
View File

@@ -1,64 +0,0 @@
.RECIPEPREFIX := >
MAKEFLAGS += --no-print-directory
CMAKE ?= cmake
CMAKE_BUILD_DIR ?= build-cmake
CMAKE_BUILD_TYPE ?= Release
CMAKE_GENERATOR ?=
CMAKE_EXTRA_ARGS ?=
APPS ?=
WERROR ?= ON
KIT_CC ?=
KIT_LD ?=
ifeq ($(strip $(CMAKE_GENERATOR)),)
GEN_ARG :=
else
GEN_ARG := -G "$(CMAKE_GENERATOR)"
endif
APPS_ARG :=
ifneq ($(strip $(APPS)),)
APPS_ARG := -DCLEONOS_KIT_APP_NAMES=$(APPS)
endif
KIT_CC_ARG :=
ifneq ($(strip $(KIT_CC)),)
KIT_CC_ARG := -DCLEONOS_KIT_CC=$(KIT_CC)
endif
KIT_LD_ARG :=
ifneq ($(strip $(KIT_LD)),)
KIT_LD_ARG := -DCLEONOS_KIT_LD=$(KIT_LD)
endif
.PHONY: all configure reconfigure apps clean clean-all help
all: apps
configure:
> @$(CMAKE) -S . -B $(CMAKE_BUILD_DIR) $(GEN_ARG) -DCMAKE_BUILD_TYPE=$(CMAKE_BUILD_TYPE) -DCLEONOS_KIT_ENABLE_WERROR=$(WERROR) $(APPS_ARG) $(KIT_CC_ARG) $(KIT_LD_ARG) $(CMAKE_EXTRA_ARGS)
reconfigure:
> @$(CMAKE) -E rm -rf $(CMAKE_BUILD_DIR)
> @$(MAKE) configure CMAKE_BUILD_TYPE="$(CMAKE_BUILD_TYPE)" CMAKE_GENERATOR="$(CMAKE_GENERATOR)" CMAKE_EXTRA_ARGS="$(CMAKE_EXTRA_ARGS)" APPS="$(APPS)" WERROR="$(WERROR)" KIT_CC="$(KIT_CC)" KIT_LD="$(KIT_LD)"
apps: configure
> @$(CMAKE) --build $(CMAKE_BUILD_DIR) --target apps
clean:
> @if [ -d "$(CMAKE_BUILD_DIR)" ]; then \
> $(CMAKE) --build $(CMAKE_BUILD_DIR) --target clean; \
> fi
clean-all:
> @$(CMAKE) -E rm -rf $(CMAKE_BUILD_DIR) build
help:
> @echo "CLeonOS kit build wrapper"
> @echo " make apps"
> @echo " make apps APPS=hello"
> @echo " make apps APPS=hello,foo"
> @echo " make apps KIT_CC=x86_64-elf-gcc KIT_LD=x86_64-elf-ld"
> @echo " make clean"
> @echo " make clean-all"

97
kit/README.md
View File

@@ -1,97 +0,0 @@
# CLeonOS App Kit
[English](README.md) | [简体中文](README.zh-CN.md)
`kit/` is a standalone user-app SDK for CLeonOS.
It builds ring3 ELF apps **without** depending on CLKS kernel source.
## Toolchain
Use an **ELF** toolchain (not MinGW PE/COFF):
- Recommended: `x86_64-elf-gcc` + `x86_64-elf-ld`
- Alternative: `clang` + ELF-mode `ld.lld`
## What Is Included
- User runtime (`runtime/`) copied from CLeonOS userland
- Syscall/libc-like headers (`include/`)
- User linker script (`linker/user.ld`)
- CMake project and Makefile wrapper
- Sample app: `apps/hello/main.c`
Default sample behavior:
- prints `Hello world!`
## Quick Start
```bash
cd kit
make apps
```
Output ELF files are generated under:
```text
kit/build/apps/*.elf
```
## Build Only Specific Apps
Build one app:
```bash
make apps APPS=hello
```
Build multiple apps:
```bash
make apps APPS=hello,foo,bar
```
Each app must be a directory under `apps/<name>/` with one or more `.c` files.
## App Entry
By default, kit enables `runtime/main_adapter.c`, so your app can define standard:
```c
int main(int argc, char **argv)
```
If you need raw CLeonOS entry (`cleonos_app_main(int,char**,char**)`), configure with:
```bash
cmake -S . -B build-cmake -DCLEONOS_KIT_USE_MAIN_ADAPTER=OFF
```
## CMake Direct Usage
```bash
cmake -S . -B build-cmake -DCMAKE_BUILD_TYPE=Release
cmake --build build-cmake --target apps
```
Explicit ELF toolchain example:
```bash
cmake -S . -B build-cmake \
-DCLEONOS_KIT_CC=x86_64-elf-gcc \
-DCLEONOS_KIT_LD=x86_64-elf-ld
cmake --build build-cmake --target apps
```
Useful options:
- `-DCLEONOS_KIT_APP_NAMES=hello,foo`
- `-DCLEONOS_KIT_ENABLE_WERROR=OFF`
- `-DCLEONOS_KIT_OUTPUT_DIR=<path>`
## Add New App
1. Create directory: `apps/myapp/`
2. Add source file(s), for example `apps/myapp/main.c`
3. Rebuild with `make apps`
Kit auto-discovers app directories.

97
kit/README.zh-CN.md
View File

@@ -1,97 +0,0 @@
# CLeonOS 应用开发套件
[English](README.md) | [简体中文](README.zh-CN.md)
`kit/` 是一个独立的 CLeonOS 用户态应用 SDK。
它可以在**不依赖 CLKS 内核源码**的情况下构建 ring3 ELF 程序。
## 工具链要求
请使用 **ELF** 目标工具链（不要使用 MinGW 的 PE/COFF 目标）：
- 推荐：`x86_64-elf-gcc` + `x86_64-elf-ld`
- 备选：`clang` + ELF 模式 `ld.lld`
## 套件内容
- 来自 CLeonOS 用户态的运行时实现（`runtime/`）
- syscall / libc 风格头文件（`include/`）
- 用户态链接脚本（`linker/user.ld`）
- 独立的 CMake 工程和 Makefile 包装
- 示例程序：`apps/hello/main.c`
默认示例行为：
- 输出 `Hello world!`
## 快速开始
```bash
cd kit
make apps
```
生成的 ELF 位于：
```text
kit/build/apps/*.elf
```
## 仅构建指定应用
只构建一个：
```bash
make apps APPS=hello
```
构建多个：
```bash
make apps APPS=hello,foo,bar
```
每个应用应放在 `apps/<name>/` 目录，并包含一个或多个 `.c` 文件。
## 程序入口
默认启用 `runtime/main_adapter.c`，因此应用可以直接写标准入口：
```c
int main(int argc, char **argv)
```
如果你要使用原始入口 `cleonos_app_main(int,char**,char**)`，可关闭适配器：
```bash
cmake -S . -B build-cmake -DCLEONOS_KIT_USE_MAIN_ADAPTER=OFF
```
## 直接使用 CMake
```bash
cmake -S . -B build-cmake -DCMAKE_BUILD_TYPE=Release
cmake --build build-cmake --target apps
```
显式指定 ELF 工具链示例：
```bash
cmake -S . -B build-cmake \
-DCLEONOS_KIT_CC=x86_64-elf-gcc \
-DCLEONOS_KIT_LD=x86_64-elf-ld
cmake --build build-cmake --target apps
```
常用选项：
- `-DCLEONOS_KIT_APP_NAMES=hello,foo`
- `-DCLEONOS_KIT_ENABLE_WERROR=OFF`
- `-DCLEONOS_KIT_OUTPUT_DIR=<path>`
## 新增应用
1. 创建目录：`apps/myapp/`
2. 添加源码（例如 `apps/myapp/main.c`）
3. 执行 `make apps`
kit 会自动扫描并构建应用目录。

6
kit/apps/hello/main.c
View File

@@ -1,6 +0,0 @@
#include <stdio.h>
int main(void) {
printf("Hello world!\n");
return 0;
}

9
kit/include/cleonos_rust_bridge.h
View File

@@ -1,9 +0,0 @@
#ifndef CLEONOS_RUST_BRIDGE_H
#define CLEONOS_RUST_BRIDGE_H
typedef unsigned long long u64;
typedef unsigned long long usize;
u64 cleonos_rust_guarded_len(const unsigned char *ptr, usize max_len);
#endif

6
kit/include/cleonos_stdio.h
View File

@@ -1,6 +0,0 @@
#ifndef CLEONOS_STDIO_H
#define CLEONOS_STDIO_H
#include <stdio.h>
#endif

256
kit/include/cleonos_syscall.h
View File

@@ -1,256 +0,0 @@
#ifndef CLEONOS_SYSCALL_H
#define CLEONOS_SYSCALL_H
typedef unsigned long long u64;
typedef unsigned long long usize;
#define CLEONOS_FS_NAME_MAX 96ULL
#define CLEONOS_PROC_PATH_MAX 192ULL
#define CLEONOS_PROC_STATE_UNUSED 0ULL
#define CLEONOS_PROC_STATE_PENDING 1ULL
#define CLEONOS_PROC_STATE_RUNNING 2ULL
#define CLEONOS_PROC_STATE_EXITED 3ULL
#define CLEONOS_PROC_STATE_STOPPED 4ULL
#define CLEONOS_SIGKILL 9ULL
#define CLEONOS_SIGTERM 15ULL
#define CLEONOS_SIGCONT 18ULL
#define CLEONOS_SIGSTOP 19ULL
#define CLEONOS_O_RDONLY 0x0000ULL
#define CLEONOS_O_WRONLY 0x0001ULL
#define CLEONOS_O_RDWR 0x0002ULL
#define CLEONOS_O_CREAT 0x0040ULL
#define CLEONOS_O_TRUNC 0x0200ULL
#define CLEONOS_O_APPEND 0x0400ULL
#define CLEONOS_FD_INHERIT ((u64) - 1)
typedef struct cleonos_proc_snapshot {
u64 pid;
u64 ppid;
u64 state;
u64 started_tick;
u64 exited_tick;
u64 exit_status;
u64 runtime_ticks;
u64 mem_bytes;
u64 tty_index;
u64 last_signal;
u64 last_fault_vector;
u64 last_fault_error;
u64 last_fault_rip;
char path[CLEONOS_PROC_PATH_MAX];
} cleonos_proc_snapshot;
typedef struct cleonos_fb_info {
u64 width;
u64 height;
u64 pitch;
u64 bpp;
} cleonos_fb_info;
typedef struct cleonos_fb_blit_req {
u64 pixels_ptr;
u64 src_width;
u64 src_height;
u64 src_pitch_bytes;
u64 dst_x;
u64 dst_y;
u64 scale;
} cleonos_fb_blit_req;
#define CLEONOS_SYSCALL_LOG_WRITE 0ULL
#define CLEONOS_SYSCALL_TIMER_TICKS 1ULL
#define CLEONOS_SYSCALL_TASK_COUNT 2ULL
#define CLEONOS_SYSCALL_CUR_TASK 3ULL
#define CLEONOS_SYSCALL_SERVICE_COUNT 4ULL
#define CLEONOS_SYSCALL_SERVICE_READY_COUNT 5ULL
#define CLEONOS_SYSCALL_CONTEXT_SWITCHES 6ULL
#define CLEONOS_SYSCALL_KELF_COUNT 7ULL
#define CLEONOS_SYSCALL_KELF_RUNS 8ULL
#define CLEONOS_SYSCALL_FS_NODE_COUNT 9ULL
#define CLEONOS_SYSCALL_FS_CHILD_COUNT 10ULL
#define CLEONOS_SYSCALL_FS_GET_CHILD_NAME 11ULL
#define CLEONOS_SYSCALL_FS_READ 12ULL
#define CLEONOS_SYSCALL_EXEC_PATH 13ULL
#define CLEONOS_SYSCALL_EXEC_REQUESTS 14ULL
#define CLEONOS_SYSCALL_EXEC_SUCCESS 15ULL
#define CLEONOS_SYSCALL_USER_SHELL_READY 16ULL
#define CLEONOS_SYSCALL_USER_EXEC_REQUESTED 17ULL
#define CLEONOS_SYSCALL_USER_LAUNCH_TRIES 18ULL
#define CLEONOS_SYSCALL_USER_LAUNCH_OK 19ULL
#define CLEONOS_SYSCALL_USER_LAUNCH_FAIL 20ULL
#define CLEONOS_SYSCALL_TTY_COUNT 21ULL
#define CLEONOS_SYSCALL_TTY_ACTIVE 22ULL
#define CLEONOS_SYSCALL_TTY_SWITCH 23ULL
#define CLEONOS_SYSCALL_TTY_WRITE 24ULL
#define CLEONOS_SYSCALL_TTY_WRITE_CHAR 25ULL
#define CLEONOS_SYSCALL_KBD_GET_CHAR 26ULL
#define CLEONOS_SYSCALL_FS_STAT_TYPE 27ULL
#define CLEONOS_SYSCALL_FS_STAT_SIZE 28ULL
#define CLEONOS_SYSCALL_FS_MKDIR 29ULL
#define CLEONOS_SYSCALL_FS_WRITE 30ULL
#define CLEONOS_SYSCALL_FS_APPEND 31ULL
#define CLEONOS_SYSCALL_FS_REMOVE 32ULL
#define CLEONOS_SYSCALL_LOG_JOURNAL_COUNT 33ULL
#define CLEONOS_SYSCALL_LOG_JOURNAL_READ 34ULL
#define CLEONOS_SYSCALL_KBD_BUFFERED 35ULL
#define CLEONOS_SYSCALL_KBD_PUSHED 36ULL
#define CLEONOS_SYSCALL_KBD_POPPED 37ULL
#define CLEONOS_SYSCALL_KBD_DROPPED 38ULL
#define CLEONOS_SYSCALL_KBD_HOTKEY_SWITCHES 39ULL
#define CLEONOS_SYSCALL_GETPID 40ULL
#define CLEONOS_SYSCALL_SPAWN_PATH 41ULL
#define CLEONOS_SYSCALL_WAITPID 42ULL
#define CLEONOS_SYSCALL_EXIT 43ULL
#define CLEONOS_SYSCALL_SLEEP_TICKS 44ULL
#define CLEONOS_SYSCALL_YIELD 45ULL
#define CLEONOS_SYSCALL_SHUTDOWN 46ULL
#define CLEONOS_SYSCALL_RESTART 47ULL
#define CLEONOS_SYSCALL_AUDIO_AVAILABLE 48ULL
#define CLEONOS_SYSCALL_AUDIO_PLAY_TONE 49ULL
#define CLEONOS_SYSCALL_AUDIO_STOP 50ULL
#define CLEONOS_SYSCALL_EXEC_PATHV 51ULL
#define CLEONOS_SYSCALL_SPAWN_PATHV 52ULL
#define CLEONOS_SYSCALL_PROC_ARGC 53ULL
#define CLEONOS_SYSCALL_PROC_ARGV 54ULL
#define CLEONOS_SYSCALL_PROC_ENVC 55ULL
#define CLEONOS_SYSCALL_PROC_ENV 56ULL
#define CLEONOS_SYSCALL_PROC_LAST_SIGNAL 57ULL
#define CLEONOS_SYSCALL_PROC_FAULT_VECTOR 58ULL
#define CLEONOS_SYSCALL_PROC_FAULT_ERROR 59ULL
#define CLEONOS_SYSCALL_PROC_FAULT_RIP 60ULL
#define CLEONOS_SYSCALL_PROC_COUNT 61ULL
#define CLEONOS_SYSCALL_PROC_PID_AT 62ULL
#define CLEONOS_SYSCALL_PROC_SNAPSHOT 63ULL
#define CLEONOS_SYSCALL_PROC_KILL 64ULL
#define CLEONOS_SYSCALL_KDBG_SYM 65ULL
#define CLEONOS_SYSCALL_KDBG_BT 66ULL
#define CLEONOS_SYSCALL_KDBG_REGS 67ULL
#define CLEONOS_SYSCALL_STATS_TOTAL 68ULL
#define CLEONOS_SYSCALL_STATS_ID_COUNT 69ULL
#define CLEONOS_SYSCALL_STATS_RECENT_WINDOW 70ULL
#define CLEONOS_SYSCALL_STATS_RECENT_ID 71ULL
#define CLEONOS_SYSCALL_FD_OPEN 72ULL
#define CLEONOS_SYSCALL_FD_READ 73ULL
#define CLEONOS_SYSCALL_FD_WRITE 74ULL
#define CLEONOS_SYSCALL_FD_CLOSE 75ULL
#define CLEONOS_SYSCALL_FD_DUP 76ULL
#define CLEONOS_SYSCALL_DL_OPEN 77ULL
#define CLEONOS_SYSCALL_DL_CLOSE 78ULL
#define CLEONOS_SYSCALL_DL_SYM 79ULL
#define CLEONOS_SYSCALL_EXEC_PATHV_IO 80ULL
#define CLEONOS_SYSCALL_FB_INFO 81ULL
#define CLEONOS_SYSCALL_FB_BLIT 82ULL
#define CLEONOS_SYSCALL_FB_CLEAR 83ULL
#define CLEONOS_SYSCALL_KERNEL_VERSION 84ULL
#define CLEONOS_SYSCALL_DISK_PRESENT 85ULL
#define CLEONOS_SYSCALL_DISK_SIZE_BYTES 86ULL
#define CLEONOS_SYSCALL_DISK_SECTOR_COUNT 87ULL
#define CLEONOS_SYSCALL_DISK_FORMATTED 88ULL
#define CLEONOS_SYSCALL_DISK_FORMAT_FAT32 89ULL
#define CLEONOS_SYSCALL_DISK_MOUNT 90ULL
#define CLEONOS_SYSCALL_DISK_MOUNTED 91ULL
#define CLEONOS_SYSCALL_DISK_MOUNT_PATH 92ULL
#define CLEONOS_SYSCALL_DISK_READ_SECTOR 93ULL
#define CLEONOS_SYSCALL_DISK_WRITE_SECTOR 94ULL
u64 cleonos_syscall(u64 id, u64 arg0, u64 arg1, u64 arg2);
u64 cleonos_sys_log_write(const char *message, u64 length);
u64 cleonos_sys_timer_ticks(void);
u64 cleonos_sys_task_count(void);
u64 cleonos_sys_service_count(void);
u64 cleonos_sys_service_ready_count(void);
u64 cleonos_sys_context_switches(void);
u64 cleonos_sys_kelf_count(void);
u64 cleonos_sys_kelf_runs(void);
u64 cleonos_sys_fs_node_count(void);
u64 cleonos_sys_fs_child_count(const char *dir_path);
u64 cleonos_sys_fs_get_child_name(const char *dir_path, u64 index, char *out_name);
u64 cleonos_sys_fs_read(const char *path, char *out_buffer, u64 buffer_size);
u64 cleonos_sys_exec_path(const char *path);
u64 cleonos_sys_exec_pathv(const char *path, const char *argv_line, const char *env_line);
u64 cleonos_sys_exec_pathv_io(const char *path, const char *argv_line, const char *env_line, u64 stdin_fd,
u64 stdout_fd, u64 stderr_fd);
u64 cleonos_sys_exec_request_count(void);
u64 cleonos_sys_exec_success_count(void);
u64 cleonos_sys_user_shell_ready(void);
u64 cleonos_sys_user_exec_requested(void);
u64 cleonos_sys_user_launch_tries(void);
u64 cleonos_sys_user_launch_ok(void);
u64 cleonos_sys_user_launch_fail(void);
u64 cleonos_sys_tty_count(void);
u64 cleonos_sys_tty_active(void);
u64 cleonos_sys_tty_switch(u64 tty_index);
u64 cleonos_sys_tty_write(const char *text, u64 length);
u64 cleonos_sys_tty_write_char(char ch);
u64 cleonos_sys_kbd_get_char(void);
u64 cleonos_sys_fs_stat_type(const char *path);
u64 cleonos_sys_fs_stat_size(const char *path);
u64 cleonos_sys_fs_mkdir(const char *path);
u64 cleonos_sys_fs_write(const char *path, const char *data, u64 size);
u64 cleonos_sys_fs_append(const char *path, const char *data, u64 size);
u64 cleonos_sys_fs_remove(const char *path);
u64 cleonos_sys_log_journal_count(void);
u64 cleonos_sys_log_journal_read(u64 index_from_oldest, char *out_line, u64 out_size);
u64 cleonos_sys_kbd_buffered(void);
u64 cleonos_sys_kbd_pushed(void);
u64 cleonos_sys_kbd_popped(void);
u64 cleonos_sys_kbd_dropped(void);
u64 cleonos_sys_kbd_hotkey_switches(void);
u64 cleonos_sys_getpid(void);
u64 cleonos_sys_spawn_path(const char *path);
u64 cleonos_sys_spawn_pathv(const char *path, const char *argv_line, const char *env_line);
u64 cleonos_sys_wait_pid(u64 pid, u64 *out_status);
u64 cleonos_sys_exit(u64 status);
u64 cleonos_sys_sleep_ticks(u64 ticks);
u64 cleonos_sys_yield(void);
u64 cleonos_sys_shutdown(void);
u64 cleonos_sys_restart(void);
u64 cleonos_sys_audio_available(void);
u64 cleonos_sys_audio_play_tone(u64 hz, u64 ticks);
u64 cleonos_sys_audio_stop(void);
u64 cleonos_sys_proc_argc(void);
u64 cleonos_sys_proc_argv(u64 index, char *out_value, u64 out_size);
u64 cleonos_sys_proc_envc(void);
u64 cleonos_sys_proc_env(u64 index, char *out_value, u64 out_size);
u64 cleonos_sys_proc_last_signal(void);
u64 cleonos_sys_proc_fault_vector(void);
u64 cleonos_sys_proc_fault_error(void);
u64 cleonos_sys_proc_fault_rip(void);
u64 cleonos_sys_proc_count(void);
u64 cleonos_sys_proc_pid_at(u64 index, u64 *out_pid);
u64 cleonos_sys_proc_snapshot(u64 pid, cleonos_proc_snapshot *out_snapshot, u64 out_size);
u64 cleonos_sys_proc_kill(u64 pid, u64 signal);
u64 cleonos_sys_kdbg_sym(u64 addr, char *out_line, u64 out_size);
u64 cleonos_sys_kdbg_bt(u64 rbp, u64 rip, char *out_text, u64 out_size);
u64 cleonos_sys_kdbg_regs(char *out_text, u64 out_size);
u64 cleonos_sys_stats_total(void);
u64 cleonos_sys_stats_id_count(u64 id);
u64 cleonos_sys_stats_recent_window(void);
u64 cleonos_sys_stats_recent_id(u64 id);
u64 cleonos_sys_fd_open(const char *path, u64 flags, u64 mode);
u64 cleonos_sys_fd_read(u64 fd, void *out_buffer, u64 size);
u64 cleonos_sys_fd_write(u64 fd, const void *buffer, u64 size);
u64 cleonos_sys_fd_close(u64 fd);
u64 cleonos_sys_fd_dup(u64 fd);
u64 cleonos_sys_dl_open(const char *path);
u64 cleonos_sys_dl_close(u64 handle);
u64 cleonos_sys_dl_sym(u64 handle, const char *symbol);
u64 cleonos_sys_fb_info(cleonos_fb_info *out_info);
u64 cleonos_sys_fb_blit(const cleonos_fb_blit_req *req);
u64 cleonos_sys_fb_clear(u64 rgb);
u64 cleonos_sys_kernel_version(char *out_version, u64 out_size);
u64 cleonos_sys_disk_present(void);
u64 cleonos_sys_disk_size_bytes(void);
u64 cleonos_sys_disk_sector_count(void);
u64 cleonos_sys_disk_formatted(void);
u64 cleonos_sys_disk_format_fat32(const char *label);
u64 cleonos_sys_disk_mount(const char *mount_path);
u64 cleonos_sys_disk_mounted(void);
u64 cleonos_sys_disk_mount_path(char *out_path, u64 out_size);
u64 cleonos_sys_disk_read_sector(u64 lba, void *out_sector);
u64 cleonos_sys_disk_write_sector(u64 lba, const void *sector_data);
#endif

6
kit/include/cleonos_version.h
View File

@@ -1,6 +0,0 @@
#ifndef CLEONOS_VERSION_H
#define CLEONOS_VERSION_H
#define CLEONOS_VERSION_STRING "1.0.0-alpha"
#endif

16
kit/include/ctype.h
View File

@@ -1,16 +0,0 @@
#ifndef CLEONOS_LIBC_CTYPE_H
#define CLEONOS_LIBC_CTYPE_H
int isspace(int ch);
int isdigit(int ch);
int isalpha(int ch);
int isalnum(int ch);
int isxdigit(int ch);
int isupper(int ch);
int islower(int ch);
int isprint(int ch);
int iscntrl(int ch);
int tolower(int ch);
int toupper(int ch);
#endif

8
kit/include/dlfcn.h
View File

@@ -1,8 +0,0 @@
#ifndef CLEONOS_LIBC_DLFCN_H
#define CLEONOS_LIBC_DLFCN_H
void *dlopen(const char *path, int flags);
void *dlsym(void *handle, const char *symbol);
int dlclose(void *handle);
#endif

27
kit/include/stdio.h
View File

@@ -1,27 +0,0 @@
#ifndef CLEONOS_LIBC_STDIO_H
#define CLEONOS_LIBC_STDIO_H
#include <stdarg.h>
#ifndef EOF
#define EOF (-1)
#endif
int putchar(int ch);
int getchar(void);
int fputc(int ch, int fd);
int fgetc(int fd);
int fputs(const char *text, int fd);
int puts(const char *text);
int vsnprintf(char *out, unsigned long out_size, const char *fmt, va_list args);
int snprintf(char *out, unsigned long out_size, const char *fmt, ...);
int vdprintf(int fd, const char *fmt, va_list args);
int dprintf(int fd, const char *fmt, ...);
int vfprintf(int fd, const char *fmt, va_list args);
int fprintf(int fd, const char *fmt, ...);
int vprintf(const char *fmt, va_list args);
int printf(const char *fmt, ...);
#endif

36
kit/include/stdlib.h
View File

@@ -1,36 +0,0 @@
#ifndef CLEONOS_LIBC_STDLIB_H
#define CLEONOS_LIBC_STDLIB_H
#include <stddef.h>
#ifndef EXIT_SUCCESS
#define EXIT_SUCCESS 0
#endif
#ifndef EXIT_FAILURE
#define EXIT_FAILURE 1
#endif
#ifndef RAND_MAX
#define RAND_MAX 32767
#endif
int abs(int value);
long labs(long value);
long long llabs(long long value);
int atoi(const char *text);
long atol(const char *text);
long long atoll(const char *text);
long strtol(const char *text, char **out_end, int base);
unsigned long strtoul(const char *text, char **out_end, int base);
long long strtoll(const char *text, char **out_end, int base);
unsigned long long strtoull(const char *text, char **out_end, int base);
void srand(unsigned int seed);
int rand(void);
void exit(int status);
void abort(void);
#endif

29
kit/include/string.h
View File

@@ -1,29 +0,0 @@
#ifndef CLEONOS_LIBC_STRING_H
#define CLEONOS_LIBC_STRING_H
#include <stddef.h>
void *memset(void *dst, int value, size_t size);
void *memcpy(void *dst, const void *src, size_t size);
void *memmove(void *dst, const void *src, size_t size);
int memcmp(const void *left, const void *right, size_t size);
void *memchr(const void *src, int value, size_t size);
size_t strlen(const char *text);
size_t strnlen(const char *text, size_t max_size);
char *strcpy(char *dst, const char *src);
char *strncpy(char *dst, const char *src, size_t size);
int strcmp(const char *left, const char *right);
int strncmp(const char *left, const char *right, size_t size);
char *strchr(const char *text, int ch);
char *strrchr(const char *text, int ch);
char *strstr(const char *haystack, const char *needle);
size_t strspn(const char *text, const char *accept);
size_t strcspn(const char *text, const char *reject);
char *strpbrk(const char *text, const char *accept);
char *strtok_r(char *text, const char *delim, char **saveptr);
char *strtok(char *text, const char *delim);
char *strcat(char *dst, const char *src);
char *strncat(char *dst, const char *src, size_t size);
#endif

29
kit/linker/user.ld
View File

@@ -1,29 +0,0 @@
OUTPUT_FORMAT(elf64-x86-64)
ENTRY(_start)
PHDRS {
text PT_LOAD FLAGS(5);
rodata PT_LOAD FLAGS(4);
data PT_LOAD FLAGS(6);
}
SECTIONS {
. = 0x00400000;
.text : ALIGN(0x1000) {
*(.text .text.*)
} :text
.rodata : ALIGN(0x1000) {
*(.rodata .rodata.*)
} :rodata
.data : ALIGN(0x1000) {
*(.data .data.*)
} :data
.bss : ALIGN(0x1000) {
*(COMMON)
*(.bss .bss.*)
} :data
}

48
kit/runtime/dlfcn.c
View File

@@ -1,48 +0,0 @@
#include <dlfcn.h>
#include <cleonos_syscall.h>
void *dlopen(const char *path, int flags) {
u64 handle;
(void)flags;
if (path == (const char *)0 || path[0] == '\0') {
return (void *)0;
}
handle = cleonos_sys_dl_open(path);
if (handle == 0ULL || handle == (u64)-1) {
return (void *)0;
}
return (void *)handle;
}
void *dlsym(void *handle, const char *symbol) {
u64 addr;
if (handle == (void *)0 || symbol == (const char *)0 || symbol[0] == '\0') {
return (void *)0;
}
addr = cleonos_sys_dl_sym((u64)handle, symbol);
if (addr == 0ULL || addr == (u64)-1) {
return (void *)0;
}
return (void *)addr;
}
int dlclose(void *handle) {
u64 rc;
if (handle == (void *)0) {
return -1;
}
rc = cleonos_sys_dl_close((u64)handle);
return (rc == (u64)-1) ? -1 : 0;
}

45
kit/runtime/libc_ctype.c
View File

@@ -1,45 +0,0 @@
#include <ctype.h>
int isspace(int ch) {
return (ch == ' ' || ch == '\t' || ch == '\r' || ch == '\n' || ch == '\v' || ch == '\f') ? 1 : 0;
}
int isdigit(int ch) {
return (ch >= '0' && ch <= '9') ? 1 : 0;
}
int isalpha(int ch) {
return ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z')) ? 1 : 0;
}
int isalnum(int ch) {
return (isalpha(ch) != 0 || isdigit(ch) != 0) ? 1 : 0;
}
int isxdigit(int ch) {
return (isdigit(ch) != 0 || (ch >= 'a' && ch <= 'f') || (ch >= 'A' && ch <= 'F')) ? 1 : 0;
}
int isupper(int ch) {
return (ch >= 'A' && ch <= 'Z') ? 1 : 0;
}
int islower(int ch) {
return (ch >= 'a' && ch <= 'z') ? 1 : 0;
}
int isprint(int ch) {
return (ch >= 0x20 && ch <= 0x7E) ? 1 : 0;
}
int iscntrl(int ch) {
return (ch >= 0x00 && ch <= 0x1F) || ch == 0x7F ? 1 : 0;
}
int tolower(int ch) {
return (isupper(ch) != 0) ? (ch - 'A' + 'a') : ch;
}
int toupper(int ch) {
return (islower(ch) != 0) ? (ch - 'a' + 'A') : ch;
}

254
kit/runtime/libc_stdlib.c
View File

@@ -1,254 +0,0 @@
#include <stdlib.h>
#include <ctype.h>
#include <limits.h>
#include <cleonos_syscall.h>
static int clib_digit_value(int ch) {
if (ch >= '0' && ch <= '9') {
return ch - '0';
}
if (ch >= 'a' && ch <= 'z') {
return 10 + (ch - 'a');
}
if (ch >= 'A' && ch <= 'Z') {
return 10 + (ch - 'A');
}
return -1;
}
static const char *clib_skip_space(const char *text) {
const char *p = text;
if (p == (const char *)0) {
return (const char *)0;
}
while (*p != '\0' && isspace((unsigned char)*p) != 0) {
p++;
}
return p;
}
int abs(int value) {
return (value < 0) ? -value : value;
}
long labs(long value) {
return (value < 0L) ? -value : value;
}
long long llabs(long long value) {
return (value < 0LL) ? -value : value;
}
int atoi(const char *text) {
return (int)strtol(text, (char **)0, 10);
}
long atol(const char *text) {
return strtol(text, (char **)0, 10);
}
long long atoll(const char *text) {
return strtoll(text, (char **)0, 10);
}
unsigned long strtoul(const char *text, char **out_end, int base) {
const char *p = clib_skip_space(text);
int negative = 0;
unsigned long value = 0UL;
int any = 0;
int overflow = 0;
if (out_end != (char **)0) {
*out_end = (char *)text;
}
if (p == (const char *)0) {
return 0UL;
}
if (*p == '+' || *p == '-') {
negative = (*p == '-') ? 1 : 0;
p++;
}
if (base == 0) {
if (p[0] == '0') {
if ((p[1] == 'x' || p[1] == 'X') && isxdigit((unsigned char)p[2]) != 0) {
base = 16;
p += 2;
} else {
base = 8;
}
} else {
base = 10;
}
} else if (base == 16) {
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
p += 2;
}
}
if (base < 2 || base > 36) {
return 0UL;
}
while (*p != '\0') {
int digit = clib_digit_value((unsigned char)*p);
if (digit < 0 || digit >= base) {
break;
}
any = 1;
if (value > (ULONG_MAX - (unsigned long)digit) / (unsigned long)base) {
overflow = 1;
value = ULONG_MAX;
} else if (overflow == 0) {
value = value * (unsigned long)base + (unsigned long)digit;
}
p++;
}
if (any == 0) {
return 0UL;
}
if (out_end != (char **)0) {
*out_end = (char *)p;
}
if (negative != 0) {
return (unsigned long)(0UL - value);
}
return value;
}
long strtol(const char *text, char **out_end, int base) {
const char *p = clib_skip_space(text);
int negative = 0;
unsigned long long value = 0ULL;
unsigned long long limit;
int any = 0;
int overflow = 0;
if (out_end != (char **)0) {
*out_end = (char *)text;
}
if (p == (const char *)0) {
return 0L;
}
if (*p == '+' || *p == '-') {
negative = (*p == '-') ? 1 : 0;
p++;
}
if (base == 0) {
if (p[0] == '0') {
if ((p[1] == 'x' || p[1] == 'X') && isxdigit((unsigned char)p[2]) != 0) {
base = 16;
p += 2;
} else {
base = 8;
}
} else {
base = 10;
}
} else if (base == 16) {
if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {
p += 2;
}
}
if (base < 2 || base > 36) {
return 0L;
}
limit = (negative != 0) ? ((unsigned long long)LONG_MAX + 1ULL) : (unsigned long long)LONG_MAX;
while (*p != '\0') {
int digit = clib_digit_value((unsigned char)*p);
if (digit < 0 || digit >= base) {
break;
}
any = 1;
if (value > (limit - (unsigned long long)digit) / (unsigned long long)base) {
overflow = 1;
value = limit;
} else if (overflow == 0) {
value = value * (unsigned long long)base + (unsigned long long)digit;
}
p++;
}
if (any == 0) {
return 0L;
}
if (out_end != (char **)0) {
*out_end = (char *)p;
}
if (overflow != 0) {
return (negative != 0) ? LONG_MIN : LONG_MAX;
}
if (negative != 0) {
if (value == ((unsigned long long)LONG_MAX + 1ULL)) {
return LONG_MIN;
}
return -(long)value;
}
return (long)value;
}
long long strtoll(const char *text, char **out_end, int base) {
return (long long)strtol(text, out_end, base);
}
unsigned long long strtoull(const char *text, char **out_end, int base) {
return (unsigned long long)strtoul(text, out_end, base);
}
static unsigned long clib_rand_state = 1UL;
void srand(unsigned int seed) {
clib_rand_state = (unsigned long)seed;
if (clib_rand_state == 0UL) {
clib_rand_state = 1UL;
}
}
int rand(void) {
clib_rand_state = (1103515245UL * clib_rand_state) + 12345UL;
return (int)((clib_rand_state >> 16) & (unsigned long)RAND_MAX);
}
void exit(int status) {
(void)cleonos_sys_exit((u64)(unsigned long long)status);
for (;;) {
(void)cleonos_sys_yield();
}
}
void abort(void) {
exit(EXIT_FAILURE);
}

445
kit/runtime/libc_string.c
View File

@@ -1,445 +0,0 @@
#include <string.h>
void *memset(void *dst, int value, size_t size) {
unsigned char *d = (unsigned char *)dst;
unsigned char byte = (unsigned char)value;
size_t i;
if (d == (unsigned char *)0) {
return dst;
}
for (i = 0U; i < size; i++) {
d[i] = byte;
}
return dst;
}
void *memcpy(void *dst, const void *src, size_t size) {
unsigned char *d = (unsigned char *)dst;
const unsigned char *s = (const unsigned char *)src;
size_t i;
if (d == (unsigned char *)0 || s == (const unsigned char *)0) {
return dst;
}
for (i = 0U; i < size; i++) {
d[i] = s[i];
}
return dst;
}
void *memmove(void *dst, const void *src, size_t size) {
unsigned char *d = (unsigned char *)dst;
const unsigned char *s = (const unsigned char *)src;
size_t i;
if (d == (unsigned char *)0 || s == (const unsigned char *)0 || d == s || size == 0U) {
return dst;
}
if (d < s || d >= s + size) {
for (i = 0U; i < size; i++) {
d[i] = s[i];
}
} else {
for (i = size; i > 0U; i--) {
d[i - 1U] = s[i - 1U];
}
}
return dst;
}
int memcmp(const void *left, const void *right, size_t size) {
const unsigned char *a = (const unsigned char *)left;
const unsigned char *b = (const unsigned char *)right;
size_t i;
if (a == b || size == 0U) {
return 0;
}
if (a == (const unsigned char *)0) {
return -1;
}
if (b == (const unsigned char *)0) {
return 1;
}
for (i = 0U; i < size; i++) {
if (a[i] != b[i]) {
return (a[i] < b[i]) ? -1 : 1;
}
}
return 0;
}
void *memchr(const void *src, int value, size_t size) {
const unsigned char *s = (const unsigned char *)src;
unsigned char needle = (unsigned char)value;
size_t i;
if (s == (const unsigned char *)0) {
return (void *)0;
}
for (i = 0U; i < size; i++) {
if (s[i] == needle) {
return (void *)(s + i);
}
}
return (void *)0;
}
size_t strlen(const char *text) {
size_t len = 0U;
if (text == (const char *)0) {
return 0U;
}
while (text[len] != '\0') {
len++;
}
return len;
}
size_t strnlen(const char *text, size_t max_size) {
size_t len = 0U;
if (text == (const char *)0) {
return 0U;
}
while (len < max_size && text[len] != '\0') {
len++;
}
return len;
}
char *strcpy(char *dst, const char *src) {
size_t i = 0U;
if (dst == (char *)0 || src == (const char *)0) {
return dst;
}
while (src[i] != '\0') {
dst[i] = src[i];
i++;
}
dst[i] = '\0';
return dst;
}
char *strncpy(char *dst, const char *src, size_t size) {
size_t i = 0U;
if (dst == (char *)0 || src == (const char *)0) {
return dst;
}
while (i < size && src[i] != '\0') {
dst[i] = src[i];
i++;
}
while (i < size) {
dst[i++] = '\0';
}
return dst;
}
int strcmp(const char *left, const char *right) {
size_t i = 0U;
if (left == right) {
return 0;
}
if (left == (const char *)0) {
return -1;
}
if (right == (const char *)0) {
return 1;
}
while (left[i] != '\0' && right[i] != '\0') {
if (left[i] != right[i]) {
return (left[i] < right[i]) ? -1 : 1;
}
i++;
}
if (left[i] == right[i]) {
return 0;
}
return (left[i] < right[i]) ? -1 : 1;
}
int strncmp(const char *left, const char *right, size_t size) {
size_t i = 0U;
if (size == 0U || left == right) {
return 0;
}
if (left == (const char *)0) {
return -1;
}
if (right == (const char *)0) {
return 1;
}
while (i < size && left[i] != '\0' && right[i] != '\0') {
if (left[i] != right[i]) {
return (left[i] < right[i]) ? -1 : 1;
}
i++;
}
if (i == size) {
return 0;
}
if (left[i] == right[i]) {
return 0;
}
return (left[i] < right[i]) ? -1 : 1;
}
char *strchr(const char *text, int ch) {
char needle = (char)ch;
size_t i = 0U;
if (text == (const char *)0) {
return (char *)0;
}
while (text[i] != '\0') {
if (text[i] == needle) {
return (char *)(text + i);
}
i++;
}
if (needle == '\0') {
return (char *)(text + i);
}
return (char *)0;
}
char *strrchr(const char *text, int ch) {
char needle = (char)ch;
const char *last = (const char *)0;
size_t i = 0U;
if (text == (const char *)0) {
return (char *)0;
}
while (text[i] != '\0') {
if (text[i] == needle) {
last = text + i;
}
i++;
}
if (needle == '\0') {
return (char *)(text + i);
}
return (char *)last;
}
char *strstr(const char *haystack, const char *needle) {
size_t i;
size_t j;
size_t nlen;
if (haystack == (const char *)0 || needle == (const char *)0) {
return (char *)0;
}
nlen = strlen(needle);
if (nlen == 0U) {
return (char *)haystack;
}
for (i = 0U; haystack[i] != '\0'; i++) {
if (haystack[i] != needle[0]) {
continue;
}
for (j = 1U; j < nlen; j++) {
if (haystack[i + j] == '\0' || haystack[i + j] != needle[j]) {
break;
}
}
if (j == nlen) {
return (char *)(haystack + i);
}
}
return (char *)0;
}
static int clib_delim_contains(const char *delim, char ch) {
size_t i = 0U;
if (delim == (const char *)0) {
return 0;
}
while (delim[i] != '\0') {
if (delim[i] == ch) {
return 1;
}
i++;
}
return 0;
}
size_t strspn(const char *text, const char *accept) {
size_t n = 0U;
if (text == (const char *)0 || accept == (const char *)0) {
return 0U;
}
while (text[n] != '\0' && clib_delim_contains(accept, text[n]) != 0) {
n++;
}
return n;
}
size_t strcspn(const char *text, const char *reject) {
size_t n = 0U;
if (text == (const char *)0 || reject == (const char *)0) {
return 0U;
}
while (text[n] != '\0' && clib_delim_contains(reject, text[n]) == 0) {
n++;
}
return n;
}
char *strpbrk(const char *text, const char *accept) {
size_t i = 0U;
if (text == (const char *)0 || accept == (const char *)0) {
return (char *)0;
}
while (text[i] != '\0') {
if (clib_delim_contains(accept, text[i]) != 0) {
return (char *)(text + i);
}
i++;
}
return (char *)0;
}
char *strtok_r(char *text, const char *delim, char **saveptr) {
char *start;
char *cursor;
if (delim == (const char *)0 || saveptr == (char **)0) {
return (char *)0;
}
if (text != (char *)0) {
cursor = text;
} else {
cursor = *saveptr;
}
if (cursor == (char *)0) {
return (char *)0;
}
while (*cursor != '\0' && clib_delim_contains(delim, *cursor) != 0) {
cursor++;
}
if (*cursor == '\0') {
*saveptr = cursor;
return (char *)0;
}
start = cursor;
while (*cursor != '\0' && clib_delim_contains(delim, *cursor) == 0) {
cursor++;
}
if (*cursor == '\0') {
*saveptr = cursor;
} else {
*cursor = '\0';
*saveptr = cursor + 1;
}
return start;
}
char *strtok(char *text, const char *delim) {
static char *state = (char *)0;
return strtok_r(text, delim, &state);
}
char *strcat(char *dst, const char *src) {
size_t dlen = strlen(dst);
size_t i = 0U;
if (dst == (char *)0 || src == (const char *)0) {
return dst;
}
while (src[i] != '\0') {
dst[dlen + i] = src[i];
i++;
}
dst[dlen + i] = '\0';
return dst;
}
char *strncat(char *dst, const char *src, size_t size) {
size_t dlen = strlen(dst);
size_t i = 0U;
if (dst == (char *)0 || src == (const char *)0) {
return dst;
}
while (i < size && src[i] != '\0') {
dst[dlen + i] = src[i];
i++;
}
dst[dlen + i] = '\0';
return dst;
}

8
kit/runtime/main_adapter.c
View File

@@ -1,8 +0,0 @@
#include <cleonos_syscall.h>
extern int main(int argc, char **argv);
int cleonos_app_main(int argc, char **argv, char **envp) {
(void)envp;
return main(argc, argv);
}

53
kit/runtime/runtime.c
View File

@@ -1,53 +0,0 @@
#include <cleonos_syscall.h>
#define CLEONOS_RUNTIME_ARGV_MAX 24ULL
#define CLEONOS_RUNTIME_ENVP_MAX 24ULL
#define CLEONOS_RUNTIME_ITEM_MAX 128ULL
extern int cleonos_app_main(int argc, char **argv, char **envp);
extern void cleonos_cmd_runtime_pre_main(char **envp) __attribute__((weak));
u64 _start(void) {
static char argv_items[CLEONOS_RUNTIME_ARGV_MAX][CLEONOS_RUNTIME_ITEM_MAX];
static char env_items[CLEONOS_RUNTIME_ENVP_MAX][CLEONOS_RUNTIME_ITEM_MAX];
static char *argv_ptrs[CLEONOS_RUNTIME_ARGV_MAX + 1ULL];
static char *env_ptrs[CLEONOS_RUNTIME_ENVP_MAX + 1ULL];
u64 argc = 0ULL;
u64 envc = 0ULL;
u64 i;
int code;
argc = cleonos_sys_proc_argc();
envc = cleonos_sys_proc_envc();
if (argc > CLEONOS_RUNTIME_ARGV_MAX) {
argc = CLEONOS_RUNTIME_ARGV_MAX;
}
if (envc > CLEONOS_RUNTIME_ENVP_MAX) {
envc = CLEONOS_RUNTIME_ENVP_MAX;
}
for (i = 0ULL; i < argc; i++) {
argv_items[i][0] = '\0';
(void)cleonos_sys_proc_argv(i, argv_items[i], CLEONOS_RUNTIME_ITEM_MAX);
argv_ptrs[i] = argv_items[i];
}
argv_ptrs[argc] = (char *)0;
for (i = 0ULL; i < envc; i++) {
env_items[i][0] = '\0';
(void)cleonos_sys_proc_env(i, env_items[i], CLEONOS_RUNTIME_ITEM_MAX);
env_ptrs[i] = env_items[i];
}
env_ptrs[envc] = (char *)0;
if (cleonos_cmd_runtime_pre_main != (void (*)(char **))0) {
cleonos_cmd_runtime_pre_main(env_ptrs);
}
code = cleonos_app_main((int)argc, argv_ptrs, env_ptrs);
return (u64)code;
}

712
kit/runtime/stdio.c
View File

@@ -1,712 +0,0 @@
#include <stdio.h>
#include <cleonos_syscall.h>
typedef unsigned long clio_size_t;
#define CLIO_SINK_FD 1
#define CLIO_SINK_BUF 2
struct clio_sink {
int mode;
int fd;
char *buffer;
clio_size_t capacity;
clio_size_t count;
int failed;
};
static clio_size_t clio_strlen(const char *text) {
clio_size_t len = 0UL;
if (text == (const char *)0) {
return 0UL;
}
while (text[len] != '\0') {
len++;
}
return len;
}
static int clio_write_all_fd(int fd, const char *text, clio_size_t len) {
const char *cursor = text;
clio_size_t left = len;
if (fd < 0 || (text == (const char *)0 && len != 0UL)) {
return EOF;
}
while (left > 0UL) {
u64 wrote = cleonos_sys_fd_write((u64)fd, cursor, (u64)left);
clio_size_t progressed;
if (wrote == 0ULL || wrote == (u64)-1) {
return EOF;
}
progressed = (wrote > (u64)left) ? left : (clio_size_t)wrote;
cursor += progressed;
left -= progressed;
}
if (len > 0x7FFFFFFFUL) {
return 0x7FFFFFFF;
}
return (int)len;
}
static void clio_sink_init_fd(struct clio_sink *sink, int fd) {
sink->mode = CLIO_SINK_FD;
sink->fd = fd;
sink->buffer = (char *)0;
sink->capacity = 0UL;
sink->count = 0UL;
sink->failed = 0;
}
static void clio_sink_init_buffer(struct clio_sink *sink, char *out, clio_size_t out_size) {
sink->mode = CLIO_SINK_BUF;
sink->fd = -1;
sink->buffer = out;
sink->capacity = out_size;
sink->count = 0UL;
sink->failed = 0;
if (out != (char *)0 && out_size > 0UL) {
out[0] = '\0';
}
}
static void clio_sink_finalize_buffer(struct clio_sink *sink) {
if (sink->mode != CLIO_SINK_BUF || sink->buffer == (char *)0 || sink->capacity == 0UL) {
return;
}
if (sink->count < sink->capacity) {
sink->buffer[sink->count] = '\0';
} else {
sink->buffer[sink->capacity - 1UL] = '\0';
}
}
static int clio_sink_emit(struct clio_sink *sink, const char *text, clio_size_t len) {
if (sink == (struct clio_sink *)0 || text == (const char *)0 || len == 0UL) {
return 1;
}
if (sink->mode == CLIO_SINK_FD) {
if (clio_write_all_fd(sink->fd, text, len) == EOF) {
sink->failed = 1;
return 0;
}
} else {
if (sink->buffer != (char *)0 && sink->capacity > 0UL) {
clio_size_t i;
clio_size_t start = sink->count;
clio_size_t writable = 0UL;
if (start + 1UL < sink->capacity) {
writable = (sink->capacity - 1UL) - start;
}
if (len < writable) {
writable = len;
}
for (i = 0UL; i < writable; i++) {
sink->buffer[start + i] = text[i];
}
}
}
sink->count += len;
return 1;
}
static clio_size_t clio_u64_to_base(unsigned long long value, unsigned int base, int uppercase, char *out,
clio_size_t out_size) {
char tmp[64];
clio_size_t pos = 0UL;
clio_size_t i = 0UL;
if (out == (char *)0 || out_size < 2UL || base < 2U || base > 16U) {
return 0UL;
}
if (value == 0ULL) {
out[0] = '0';
out[1] = '\0';
return 1UL;
}
while (value != 0ULL && pos < (clio_size_t)sizeof(tmp)) {
unsigned long long digit = value % (unsigned long long)base;
if (digit < 10ULL) {
tmp[pos++] = (char)('0' + digit);
} else {
char alpha = (uppercase != 0) ? 'A' : 'a';
tmp[pos++] = (char)(alpha + (char)(digit - 10ULL));
}
value /= (unsigned long long)base;
}
if (pos + 1UL > out_size) {
return 0UL;
}
while (pos > 0UL) {
pos--;
out[i++] = tmp[pos];
}
out[i] = '\0';
return i;
}
static clio_size_t clio_i64_to_dec(long long value, char *out, clio_size_t out_size) {
unsigned long long magnitude;
clio_size_t offset = 0UL;
clio_size_t len;
if (out == (char *)0 || out_size < 2UL) {
return 0UL;
}
if (value < 0LL) {
out[offset++] = '-';
if (offset + 2UL > out_size) {
return 0UL;
}
magnitude = (unsigned long long)(-(value + 1LL)) + 1ULL;
} else {
magnitude = (unsigned long long)value;
}
len = clio_u64_to_base(magnitude, 10U, 0, out + offset, out_size - offset);
if (len == 0UL) {
return 0UL;
}
return offset + len;
}
static int clio_is_digit(char ch) {
return (ch >= '0' && ch <= '9') ? 1 : 0;
}
static int clio_emit_repeat(struct clio_sink *sink, char ch, clio_size_t count) {
while (count > 0UL) {
if (clio_sink_emit(sink, &ch, 1UL) == 0) {
return 0;
}
count--;
}
return 1;
}
static int clio_emit_with_width(struct clio_sink *sink, const char *text, clio_size_t text_len, int left_align,
char pad_char, clio_size_t width) {
if (left_align == 0 && width > text_len) {
if (clio_emit_repeat(sink, pad_char, width - text_len) == 0) {
return 0;
}
}
if (text_len > 0UL && clio_sink_emit(sink, text, text_len) == 0) {
return 0;
}
if (left_align != 0 && width > text_len) {
if (clio_emit_repeat(sink, ' ', width - text_len) == 0) {
return 0;
}
}
return 1;
}
static int clio_vformat(struct clio_sink *sink, const char *fmt, va_list args) {
const char *cursor = fmt;
if (sink == (struct clio_sink *)0 || fmt == (const char *)0) {
return EOF;
}
while (*cursor != '\0') {
if (*cursor != '%') {
if (clio_sink_emit(sink, cursor, 1UL) == 0) {
return EOF;
}
cursor++;
continue;
}
cursor++;
if (*cursor == '%') {
if (clio_sink_emit(sink, "%", 1UL) == 0) {
return EOF;
}
cursor++;
continue;
}
{
int left_align = 0;
int zero_pad = 0;
clio_size_t width = 0UL;
int has_precision = 0;
clio_size_t precision = 0UL;
int length_mode = 0; /* 0: default, 1: l, 2: ll, 3: z */
char spec = *cursor;
char number_buf[96];
while (spec == '-' || spec == '0') {
if (spec == '-') {
left_align = 1;
} else if (spec == '0') {
zero_pad = 1;
}
cursor++;
spec = *cursor;
}
while (clio_is_digit(spec) != 0) {
width = (width * 10UL) + (clio_size_t)(unsigned long)(spec - '0');
cursor++;
spec = *cursor;
}
if (spec == '.') {
has_precision = 1;
precision = 0UL;
cursor++;
spec = *cursor;
while (clio_is_digit(spec) != 0) {
precision = (precision * 10UL) + (clio_size_t)(unsigned long)(spec - '0');
cursor++;
spec = *cursor;
}
}
if (spec == 'l') {
cursor++;
spec = *cursor;
length_mode = 1;
if (spec == 'l') {
cursor++;
spec = *cursor;
length_mode = 2;
}
} else if (spec == 'z') {
cursor++;
spec = *cursor;
length_mode = 3;
}
if (spec == '\0') {
break;
}
if (spec == 's') {
const char *text = va_arg(args, const char *);
clio_size_t text_len;
if (text == (const char *)0) {
text = "(null)";
}
text_len = clio_strlen(text);
if (has_precision != 0 && precision < text_len) {
text_len = precision;
}
if (clio_emit_with_width(sink, text, text_len, left_align, ' ', width) == 0) {
return EOF;
}
} else if (spec == 'c') {
char out = (char)va_arg(args, int);
char out_buf[1];
out_buf[0] = out;
if (clio_emit_with_width(sink, out_buf, 1UL, left_align, ' ', width) == 0) {
return EOF;
}
} else if (spec == 'd' || spec == 'i') {
long long value;
char sign_char = '\0';
const char *digits = number_buf;
clio_size_t digits_len;
clio_size_t leading_zeros = 0UL;
clio_size_t core_len;
int sign_emitted = 0;
if (length_mode == 2) {
value = va_arg(args, long long);
} else if (length_mode == 1) {
value = (long long)va_arg(args, long);
} else if (length_mode == 3) {
value = (long long)va_arg(args, long long);
} else {
value = (long long)va_arg(args, int);
}
digits_len = clio_i64_to_dec(value, number_buf, (clio_size_t)sizeof(number_buf));
if (digits_len == 0UL) {
return EOF;
}
if (number_buf[0] == '-') {
sign_char = '-';
digits = number_buf + 1;
digits_len--;
}
if (has_precision != 0 && precision == 0UL && value == 0LL) {
digits_len = 0UL;
}
if (has_precision != 0 && precision > digits_len) {
leading_zeros = precision - digits_len;
}
core_len = digits_len + leading_zeros + ((sign_char != '\0') ? 1UL : 0UL);
if (left_align == 0 && width > core_len) {
if (zero_pad != 0 && has_precision == 0) {
if (sign_char != '\0') {
if (clio_sink_emit(sink, &sign_char, 1UL) == 0) {
return EOF;
}
sign_emitted = 1;
}
if (clio_emit_repeat(sink, '0', width - core_len) == 0) {
return EOF;
}
} else {
if (clio_emit_repeat(sink, ' ', width - core_len) == 0) {
return EOF;
}
}
}
if (sign_char != '\0' && sign_emitted == 0) {
if (clio_sink_emit(sink, &sign_char, 1UL) == 0) {
return EOF;
}
}
if (clio_emit_repeat(sink, '0', leading_zeros) == 0) {
return EOF;
}
if (digits_len > 0UL && clio_sink_emit(sink, digits, digits_len) == 0) {
return EOF;
}
if (left_align != 0 && width > core_len) {
if (clio_emit_repeat(sink, ' ', width - core_len) == 0) {
return EOF;
}
}
} else if (spec == 'u' || spec == 'x' || spec == 'X') {
unsigned long long value;
unsigned int base = (spec == 'u') ? 10U : 16U;
int upper = (spec == 'X') ? 1 : 0;
clio_size_t digits_len;
clio_size_t leading_zeros = 0UL;
clio_size_t core_len;
char pad_char = ' ';
if (length_mode == 2) {
value = va_arg(args, unsigned long long);
} else if (length_mode == 1) {
value = (unsigned long long)va_arg(args, unsigned long);
} else if (length_mode == 3) {
value = (unsigned long long)va_arg(args, unsigned long long);
} else {
value = (unsigned long long)va_arg(args, unsigned int);
}
digits_len = clio_u64_to_base(value, base, upper, number_buf, (clio_size_t)sizeof(number_buf));
if (digits_len == 0UL) {
return EOF;
}
if (has_precision != 0 && precision == 0UL && value == 0ULL) {
digits_len = 0UL;
}
if (has_precision != 0 && precision > digits_len) {
leading_zeros = precision - digits_len;
}
core_len = digits_len + leading_zeros;
if (zero_pad != 0 && has_precision == 0 && left_align == 0) {
pad_char = '0';
}
if (left_align == 0 && width > core_len) {
if (clio_emit_repeat(sink, pad_char, width - core_len) == 0) {
return EOF;
}
}
if (clio_emit_repeat(sink, '0', leading_zeros) == 0) {
return EOF;
}
if (digits_len > 0UL && clio_sink_emit(sink, number_buf, digits_len) == 0) {
return EOF;
}
if (left_align != 0 && width > core_len) {
if (clio_emit_repeat(sink, ' ', width - core_len) == 0) {
return EOF;
}
}
} else if (spec == 'p') {
const void *ptr = va_arg(args, const void *);
unsigned long long value = (unsigned long long)(usize)ptr;
clio_size_t digits_len;
clio_size_t leading_zeros = 0UL;
clio_size_t core_len;
digits_len = clio_u64_to_base(value, 16U, 0, number_buf, (clio_size_t)sizeof(number_buf));
if (digits_len == 0UL) {
return EOF;
}
if (has_precision != 0 && precision == 0UL && value == 0ULL) {
digits_len = 0UL;
}
if (has_precision != 0 && precision > digits_len) {
leading_zeros = precision - digits_len;
}
core_len = 2UL + leading_zeros + digits_len;
if (left_align == 0 && width > core_len) {
if (clio_emit_repeat(sink, ' ', width - core_len) == 0) {
return EOF;
}
}
if (clio_sink_emit(sink, "0x", 2UL) == 0) {
return EOF;
}
if (clio_emit_repeat(sink, '0', leading_zeros) == 0) {
return EOF;
}
if (digits_len > 0UL && clio_sink_emit(sink, number_buf, digits_len) == 0) {
return EOF;
}
if (left_align != 0 && width > core_len) {
if (clio_emit_repeat(sink, ' ', width - core_len) == 0) {
return EOF;
}
}
} else if (spec == 'n') {
int *out_count = va_arg(args, int *);
if (out_count != (int *)0) {
if (sink->count > 0x7FFFFFFFUL) {
*out_count = 0x7FFFFFFF;
} else {
*out_count = (int)sink->count;
}
}
} else {
char fallback[2];
fallback[0] = spec;
fallback[1] = '\0';
if (clio_sink_emit(sink, "%", 1UL) == 0 || clio_sink_emit(sink, fallback, 1UL) == 0) {
return EOF;
}
}
cursor++;
}
}
if (sink->mode == CLIO_SINK_BUF) {
clio_sink_finalize_buffer(sink);
}
if (sink->failed != 0) {
return EOF;
}
if (sink->count > 0x7FFFFFFFUL) {
return 0x7FFFFFFF;
}
return (int)sink->count;
}
int putchar(int ch) {
char out = (char)(ch & 0xFF);
return (clio_write_all_fd(1, &out, 1UL) == EOF) ? EOF : (int)(unsigned char)out;
}
int getchar(void) {
char ch = '\0';
for (;;) {
u64 got = cleonos_sys_fd_read(0ULL, &ch, 1ULL);
if (got == 1ULL) {
return (int)(unsigned char)ch;
}
if (got == (u64)-1) {
return EOF;
}
(void)cleonos_sys_yield();
}
}
int fputc(int ch, int fd) {
char out = (char)(ch & 0xFF);
return (clio_write_all_fd(fd, &out, 1UL) == EOF) ? EOF : (int)(unsigned char)out;
}
int fgetc(int fd) {
char ch = '\0';
if (fd < 0) {
return EOF;
}
for (;;) {
u64 got = cleonos_sys_fd_read((u64)fd, &ch, 1ULL);
if (got == 1ULL) {
return (int)(unsigned char)ch;
}
if (got == (u64)-1) {
return EOF;
}
(void)cleonos_sys_yield();
}
}
int fputs(const char *text, int fd) {
clio_size_t len;
if (text == (const char *)0) {
return EOF;
}
len = clio_strlen(text);
return clio_write_all_fd(fd, text, len);
}
int puts(const char *text) {
int wrote = fputs(text, 1);
if (wrote == EOF) {
return EOF;
}
if (putchar('\n') == EOF) {
return EOF;
}
return wrote + 1;
}
int vsnprintf(char *out, unsigned long out_size, const char *fmt, va_list args) {
struct clio_sink sink;
va_list args_copy;
int rc;
clio_sink_init_buffer(&sink, out, out_size);
va_copy(args_copy, args);
rc = clio_vformat(&sink, fmt, args_copy);
va_end(args_copy);
return rc;
}
int snprintf(char *out, unsigned long out_size, const char *fmt, ...) {
va_list args;
int rc;
va_start(args, fmt);
rc = vsnprintf(out, out_size, fmt, args);
va_end(args);
return rc;
}
int vdprintf(int fd, const char *fmt, va_list args) {
struct clio_sink sink;
va_list args_copy;
int rc;
clio_sink_init_fd(&sink, fd);
va_copy(args_copy, args);
rc = clio_vformat(&sink, fmt, args_copy);
va_end(args_copy);
return rc;
}
int dprintf(int fd, const char *fmt, ...) {
va_list args;
int rc;
va_start(args, fmt);
rc = vdprintf(fd, fmt, args);
va_end(args);
return rc;
}
int vfprintf(int fd, const char *fmt, va_list args) {
return vdprintf(fd, fmt, args);
}
int fprintf(int fd, const char *fmt, ...) {
va_list args;
int rc;
va_start(args, fmt);
rc = vdprintf(fd, fmt, args);
va_end(args);
return rc;
}
int vprintf(const char *fmt, va_list args) {
return vdprintf(1, fmt, args);
}
int printf(const char *fmt, ...) {
va_list args;
int rc;
va_start(args, fmt);
rc = vdprintf(1, fmt, args);
va_end(args);
return rc;
}

413
kit/runtime/syscall.c
View File

@@ -1,413 +0,0 @@
#include <cleonos_syscall.h>
u64 cleonos_syscall(u64 id, u64 arg0, u64 arg1, u64 arg2) {
u64 ret;
__asm__ volatile("int $0x80" : "=a"(ret) : "a"(id), "b"(arg0), "c"(arg1), "d"(arg2) : "memory");
return ret;
}
u64 cleonos_sys_log_write(const char *message, u64 length) {
return cleonos_syscall(CLEONOS_SYSCALL_LOG_WRITE, (u64)message, length, 0ULL);
}
u64 cleonos_sys_timer_ticks(void) {
return cleonos_syscall(CLEONOS_SYSCALL_TIMER_TICKS, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_task_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_TASK_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_service_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_SERVICE_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_service_ready_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_SERVICE_READY_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_context_switches(void) {
return cleonos_syscall(CLEONOS_SYSCALL_CONTEXT_SWITCHES, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kelf_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KELF_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kelf_runs(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KELF_RUNS, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_node_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_NODE_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_child_count(const char *dir_path) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_CHILD_COUNT, (u64)dir_path, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_get_child_name(const char *dir_path, u64 index, char *out_name) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_GET_CHILD_NAME, (u64)dir_path, index, (u64)out_name);
}
u64 cleonos_sys_fs_read(const char *path, char *out_buffer, u64 buffer_size) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_READ, (u64)path, (u64)out_buffer, buffer_size);
}
u64 cleonos_sys_exec_path(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_EXEC_PATH, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_exec_pathv(const char *path, const char *argv_line, const char *env_line) {
return cleonos_syscall(CLEONOS_SYSCALL_EXEC_PATHV, (u64)path, (u64)argv_line, (u64)env_line);
}
struct cleonos_exec_pathv_io_req {
u64 env_line_ptr;
u64 stdin_fd;
u64 stdout_fd;
u64 stderr_fd;
};
u64 cleonos_sys_exec_pathv_io(const char *path, const char *argv_line, const char *env_line, u64 stdin_fd,
u64 stdout_fd, u64 stderr_fd) {
struct cleonos_exec_pathv_io_req req;
req.env_line_ptr = (u64)env_line;
req.stdin_fd = stdin_fd;
req.stdout_fd = stdout_fd;
req.stderr_fd = stderr_fd;
return cleonos_syscall(CLEONOS_SYSCALL_EXEC_PATHV_IO, (u64)path, (u64)argv_line, (u64)&req);
}
u64 cleonos_sys_exec_request_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_EXEC_REQUESTS, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_exec_success_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_EXEC_SUCCESS, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_user_shell_ready(void) {
return cleonos_syscall(CLEONOS_SYSCALL_USER_SHELL_READY, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_user_exec_requested(void) {
return cleonos_syscall(CLEONOS_SYSCALL_USER_EXEC_REQUESTED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_user_launch_tries(void) {
return cleonos_syscall(CLEONOS_SYSCALL_USER_LAUNCH_TRIES, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_user_launch_ok(void) {
return cleonos_syscall(CLEONOS_SYSCALL_USER_LAUNCH_OK, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_user_launch_fail(void) {
return cleonos_syscall(CLEONOS_SYSCALL_USER_LAUNCH_FAIL, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_tty_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_TTY_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_tty_active(void) {
return cleonos_syscall(CLEONOS_SYSCALL_TTY_ACTIVE, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_tty_switch(u64 tty_index) {
return cleonos_syscall(CLEONOS_SYSCALL_TTY_SWITCH, tty_index, 0ULL, 0ULL);
}
u64 cleonos_sys_tty_write(const char *text, u64 length) {
return cleonos_syscall(CLEONOS_SYSCALL_TTY_WRITE, (u64)text, length, 0ULL);
}
u64 cleonos_sys_tty_write_char(char ch) {
return cleonos_syscall(CLEONOS_SYSCALL_TTY_WRITE_CHAR, (u64)(unsigned char)ch, 0ULL, 0ULL);
}
u64 cleonos_sys_kbd_get_char(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_GET_CHAR, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_stat_type(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_STAT_TYPE, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_stat_size(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_STAT_SIZE, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_mkdir(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_MKDIR, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_fs_write(const char *path, const char *data, u64 size) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_WRITE, (u64)path, (u64)data, size);
}
u64 cleonos_sys_fs_append(const char *path, const char *data, u64 size) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_APPEND, (u64)path, (u64)data, size);
}
u64 cleonos_sys_fs_remove(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_FS_REMOVE, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_log_journal_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_LOG_JOURNAL_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_log_journal_read(u64 index_from_oldest, char *out_line, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_LOG_JOURNAL_READ, index_from_oldest, (u64)out_line, out_size);
}
u64 cleonos_sys_kbd_buffered(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_BUFFERED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kbd_pushed(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_PUSHED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kbd_popped(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_POPPED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kbd_dropped(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_DROPPED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_kbd_hotkey_switches(void) {
return cleonos_syscall(CLEONOS_SYSCALL_KBD_HOTKEY_SWITCHES, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_getpid(void) {
return cleonos_syscall(CLEONOS_SYSCALL_GETPID, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_spawn_path(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_SPAWN_PATH, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_spawn_pathv(const char *path, const char *argv_line, const char *env_line) {
return cleonos_syscall(CLEONOS_SYSCALL_SPAWN_PATHV, (u64)path, (u64)argv_line, (u64)env_line);
}
u64 cleonos_sys_wait_pid(u64 pid, u64 *out_status) {
return cleonos_syscall(CLEONOS_SYSCALL_WAITPID, pid, (u64)out_status, 0ULL);
}
u64 cleonos_sys_exit(u64 status) {
return cleonos_syscall(CLEONOS_SYSCALL_EXIT, status, 0ULL, 0ULL);
}
u64 cleonos_sys_sleep_ticks(u64 ticks) {
return cleonos_syscall(CLEONOS_SYSCALL_SLEEP_TICKS, ticks, 0ULL, 0ULL);
}
u64 cleonos_sys_yield(void) {
return cleonos_syscall(CLEONOS_SYSCALL_YIELD, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_shutdown(void) {
return cleonos_syscall(CLEONOS_SYSCALL_SHUTDOWN, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_restart(void) {
return cleonos_syscall(CLEONOS_SYSCALL_RESTART, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_audio_available(void) {
return cleonos_syscall(CLEONOS_SYSCALL_AUDIO_AVAILABLE, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_audio_play_tone(u64 hz, u64 ticks) {
return cleonos_syscall(CLEONOS_SYSCALL_AUDIO_PLAY_TONE, hz, ticks, 0ULL);
}
u64 cleonos_sys_audio_stop(void) {
return cleonos_syscall(CLEONOS_SYSCALL_AUDIO_STOP, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_argc(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_ARGC, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_argv(u64 index, char *out_value, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_ARGV, index, (u64)out_value, out_size);
}
u64 cleonos_sys_proc_envc(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_ENVC, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_env(u64 index, char *out_value, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_ENV, index, (u64)out_value, out_size);
}
u64 cleonos_sys_proc_last_signal(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_LAST_SIGNAL, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_fault_vector(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_FAULT_VECTOR, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_fault_error(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_FAULT_ERROR, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_fault_rip(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_FAULT_RIP, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_proc_pid_at(u64 index, u64 *out_pid) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_PID_AT, index, (u64)out_pid, 0ULL);
}
u64 cleonos_sys_proc_snapshot(u64 pid, cleonos_proc_snapshot *out_snapshot, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_SNAPSHOT, pid, (u64)out_snapshot, out_size);
}
u64 cleonos_sys_proc_kill(u64 pid, u64 signal) {
return cleonos_syscall(CLEONOS_SYSCALL_PROC_KILL, pid, signal, 0ULL);
}
struct cleonos_kdbg_bt_req {
u64 rbp;
u64 rip;
u64 out_ptr;
u64 out_size;
};
u64 cleonos_sys_kdbg_sym(u64 addr, char *out_line, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_KDBG_SYM, addr, (u64)out_line, out_size);
}
u64 cleonos_sys_kdbg_bt(u64 rbp, u64 rip, char *out_text, u64 out_size) {
struct cleonos_kdbg_bt_req req;
req.rbp = rbp;
req.rip = rip;
req.out_ptr = (u64)out_text;
req.out_size = out_size;
return cleonos_syscall(CLEONOS_SYSCALL_KDBG_BT, (u64)&req, 0ULL, 0ULL);
}
u64 cleonos_sys_kdbg_regs(char *out_text, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_KDBG_REGS, (u64)out_text, out_size, 0ULL);
}
u64 cleonos_sys_stats_total(void) {
return cleonos_syscall(CLEONOS_SYSCALL_STATS_TOTAL, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_stats_id_count(u64 id) {
return cleonos_syscall(CLEONOS_SYSCALL_STATS_ID_COUNT, id, 0ULL, 0ULL);
}
u64 cleonos_sys_stats_recent_window(void) {
return cleonos_syscall(CLEONOS_SYSCALL_STATS_RECENT_WINDOW, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_stats_recent_id(u64 id) {
return cleonos_syscall(CLEONOS_SYSCALL_STATS_RECENT_ID, id, 0ULL, 0ULL);
}
u64 cleonos_sys_fd_open(const char *path, u64 flags, u64 mode) {
return cleonos_syscall(CLEONOS_SYSCALL_FD_OPEN, (u64)path, flags, mode);
}
u64 cleonos_sys_fd_read(u64 fd, void *out_buffer, u64 size) {
return cleonos_syscall(CLEONOS_SYSCALL_FD_READ, fd, (u64)out_buffer, size);
}
u64 cleonos_sys_fd_write(u64 fd, const void *buffer, u64 size) {
return cleonos_syscall(CLEONOS_SYSCALL_FD_WRITE, fd, (u64)buffer, size);
}
u64 cleonos_sys_fd_close(u64 fd) {
return cleonos_syscall(CLEONOS_SYSCALL_FD_CLOSE, fd, 0ULL, 0ULL);
}
u64 cleonos_sys_fd_dup(u64 fd) {
return cleonos_syscall(CLEONOS_SYSCALL_FD_DUP, fd, 0ULL, 0ULL);
}
u64 cleonos_sys_dl_open(const char *path) {
return cleonos_syscall(CLEONOS_SYSCALL_DL_OPEN, (u64)path, 0ULL, 0ULL);
}
u64 cleonos_sys_dl_close(u64 handle) {
return cleonos_syscall(CLEONOS_SYSCALL_DL_CLOSE, handle, 0ULL, 0ULL);
}
u64 cleonos_sys_dl_sym(u64 handle, const char *symbol) {
return cleonos_syscall(CLEONOS_SYSCALL_DL_SYM, handle, (u64)symbol, 0ULL);
}
u64 cleonos_sys_fb_info(cleonos_fb_info *out_info) {
return cleonos_syscall(CLEONOS_SYSCALL_FB_INFO, (u64)out_info, 0ULL, 0ULL);
}
u64 cleonos_sys_fb_blit(const cleonos_fb_blit_req *req) {
return cleonos_syscall(CLEONOS_SYSCALL_FB_BLIT, (u64)req, 0ULL, 0ULL);
}
u64 cleonos_sys_fb_clear(u64 rgb) {
return cleonos_syscall(CLEONOS_SYSCALL_FB_CLEAR, rgb, 0ULL, 0ULL);
}
u64 cleonos_sys_kernel_version(char *out_version, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_KERNEL_VERSION, (u64)out_version, out_size, 0ULL);
}
u64 cleonos_sys_disk_present(void) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_PRESENT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_size_bytes(void) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_SIZE_BYTES, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_sector_count(void) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_SECTOR_COUNT, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_formatted(void) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_FORMATTED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_format_fat32(const char *label) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_FORMAT_FAT32, (u64)label, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_mount(const char *mount_path) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_MOUNT, (u64)mount_path, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_mounted(void) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_MOUNTED, 0ULL, 0ULL, 0ULL);
}
u64 cleonos_sys_disk_mount_path(char *out_path, u64 out_size) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_MOUNT_PATH, (u64)out_path, out_size, 0ULL);
}
u64 cleonos_sys_disk_read_sector(u64 lba, void *out_sector) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_READ_SECTOR, lba, (u64)out_sector, 0ULL);
}
u64 cleonos_sys_disk_write_sector(u64 lba, const void *sector_data) {
return cleonos_syscall(CLEONOS_SYSCALL_DISK_WRITE_SECTOR, lba, (u64)sector_data, 0ULL);
}