lolo859/ccc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

a new version + a bunch of crap (temp)

Browse Source
This commit is contained in:
lolo859
2026-02-03 17:15:04 +01:00
parent 92c2963dd6
commit 0dbeb6af86
8 changed files with 2536 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

409
log.c Normal file
View File

@@ -0,0 +1,409 @@
#include "../include/log.h"
#include "../include/page.h"
sh_uint8 kernel_log_level=0;
static inline sh_uint8 inb(sh_uint16 port) {
sh_uint8 val;
__asm__ volatile ("inb %1, %0":"=a"(val):"Nd"(port));
return val;
}
static inline void outb(sh_uint16 port,sh_uint8 val) {
__asm__ volatile ("outb %0, %1"::"a"(val),"Nd"(port));
}
SH_STATUS sh_log_send_byte(sh_uint8 b) {
while (!(inb(SH_LOG_SERIAL_PORT_COM1+5) & 0x20));
outb(SH_LOG_SERIAL_PORT_COM1,b);
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_send_string(const char* str) {
while (*str) {
sh_log_send_byte(*str++);
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_send_uintn(sh_uint64 n) {
char buf[20];
sh_uint32 i=0;
if (n==0) {
sh_log_send_byte('0');
return SH_STATUS_SUCCESS;
}
while (n>0) {
buf[i++]='0'+(n%10);
n/=10;
}
while (i--) {
sh_log_send_byte(buf[i]);
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_send_uintn_hex(sh_uint64 n) {
char buf[16];
sh_uint32 i=0;
const char hex_digits[]="0123456789ABCDEF";
if (n==0) {
sh_log_send_byte('0');
return SH_STATUS_SUCCESS;
}
while (n>0) {
buf[i++]=hex_digits[n & 0xF];
n>>=4;
}
while (i--) {
sh_log_send_byte(buf[i]);
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_send_double(double value) {
if (value<0) {
sh_log_send_byte('-');
value=-value;
}
sh_uint64 integer_part=(sh_uint64)value;
double fractional_part=value-(double)integer_part;
SH_STATUS status=sh_log_send_uintn(integer_part);
if (status!=SH_STATUS_SUCCESS) return status;
status=sh_log_send_byte('.');
if (status!=SH_STATUS_SUCCESS) return status;
for (int i=0;i<6;i++) {
fractional_part*=10.0;
sh_uint64 digit=(sh_uint64)fractional_part;
status=sh_log_send_byte('0'+(sh_uint8)digit);
if (status!=SH_STATUS_SUCCESS) return status;
fractional_part-=(double)digit;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_send_payload(sh_log_OUTPUT_PAYLOAD *payload) {
if (payload==SH_NULLPTR) {
return SH_STATUS_INVALID_PARAMETER;
}
if (!(sh_log_output_type_valid(payload->output_type))) {
return SH_STATUS_INVALID_PARAMETER;
}
if (!(sh_log_output_source_valid(payload->output_source))) {
return SH_STATUS_INVALID_PARAMETER;
}
if (payload->output_source!=SH_LOG_SOURCE_TEST && payload->output_type<kernel_log_level) {
return SH_STATUS_SUCCESS;
}
sh_log_send_string("[Shelter:");
if (payload->output_source==SH_LOG_SOURCE_MAIN) {
sh_log_send_string("Main@");
} else if (payload->output_source==SH_LOG_SOURCE_CONF) {
sh_log_send_string("Conf@");
} else if (payload->output_source==SH_LOG_SOURCE_PAGE) {
sh_log_send_string("Page@");
} else if (payload->output_source==SH_LOG_SOURCE_SLAB) {
sh_log_send_string("Slab@");
} else if (payload->output_source==SH_LOG_SOURCE_TEST) {
sh_log_send_string("Test@");
}
if (payload->output_type==SH_LOG_DEBUG) {
sh_log_send_string("Debug] ");
} else if (payload->output_type==SH_LOG_LOG) {
sh_log_send_string("Log] ");
} else if (payload->output_type==SH_LOG_WARNING) {
sh_log_send_string("Warning] ");
} else if (payload->output_type==SH_LOG_ERROR) {
sh_log_send_string("Error] ");
} else if (payload->output_type==SH_LOG_CRITICAL) {
sh_log_send_string("Critical] ");
} else if (payload->output_type==SH_LOG_FATAL) {
sh_log_send_string("Fatal] ");
} else if (payload->output_type==SH_LOG_TEST) {
sh_log_send_string("Test] ");
}
sh_log_send_uintn(payload->tsc_value);
sh_log_send_string(" : ");
sh_log_send_string(payload->message_pointer);
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_load_log_level(sh_uint8 log_level) {
kernel_log_level=log_level;
return SH_STATUS_SUCCESS;
}
sh_uint8 sh_log_get_log_level() {
return kernel_log_level;
}
SH_STATUS sh_log_test(const char* str) {
if (str==SH_NULLPTR) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_TEST,
.output_source=SH_LOG_SOURCE_TEST,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_debug(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_DEBUG,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_log(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_LOG,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_warning(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_WARNING,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_error(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_ERROR,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_critical(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_CRITICAL,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_fatal(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_FATAL,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
sh_log_send_string("\n");
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_ltest(const char* str) {
if (str==SH_NULLPTR) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_TEST,
.output_source=SH_LOG_SOURCE_TEST,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_ldebug(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_DEBUG,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_llog(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_LOG,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_lwarning(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_WARNING,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_lerror(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_ERROR,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_lcritical(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_CRITICAL,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_lfatal(const char* str,sh_log_OUTPUT_SOURCE source) {
if (str==SH_NULLPTR || !(sh_log_output_source_valid(source))) {
return SH_STATUS_INVALID_PARAMETER;
}
sh_log_OUTPUT_PAYLOAD payload={
.output_type=SH_LOG_FATAL,
.output_source=source,
.tsc_value=sh_tsc_get_kernel_current_tsc(),
.message_pointer=str
};
SH_STATUS status=sh_log_send_payload(&payload);
if (sh_status_error(status)) {
return status;
}
return SH_STATUS_SUCCESS;
}
SH_STATUS sh_log_mem_stats(sh_log_OUTPUT_SOURCE source) {
sh_page_MEM_STATS mem_stats;
sh_page_get_memory_stats(&mem_stats);
if (sh_log_get_log_level()<=1) {
sh_log_llog("Total memory installed (bytes) : ",source);
sh_log_send_uintn(mem_stats.memory_total_bytes);
sh_log_send_string(" / 0x");
sh_log_send_uintn_hex(mem_stats.memory_total_bytes);
sh_log_send_string("\n");
sh_log_llog("Total memory installed (pages) : ",source);
sh_log_send_uintn(mem_stats.memory_total_pages);
sh_log_send_string(" / 0x");
sh_log_send_uintn_hex(mem_stats.memory_total_pages);
sh_log_send_string("\n");
sh_log_llog("Free memory : ",source);
sh_log_send_double(mem_stats.free_ratio*100);
sh_log_send_string("%\n");
sh_log_llog("Used memory : ",source);
sh_log_send_double(mem_stats.used_ratio*100);
sh_log_send_string("%\n");
sh_log_llog("Free pages : ",source);
sh_log_send_uintn(mem_stats.free_pages);
sh_log_send_string("\n");
sh_log_llog("Used pages : ",source);
sh_log_send_uintn(mem_stats.used_pages);
sh_log_send_string("\n");
sh_log_llog("Largest free block (pages) : ",source);
sh_log_send_uintn(mem_stats.largest_free_block);
sh_log_send_string("\n");
sh_log_llog("Largest used block (pages) : ",source);
sh_log_send_uintn(mem_stats.largest_used_block);
sh_log_send_string("\n");
sh_log_llog("Free block count : ",source);
sh_log_send_uintn(mem_stats.free_blocks_count);
sh_log_send_string("\n");
sh_log_llog("Used block count : ",source);
sh_log_send_uintn(mem_stats.used_blocks_count);
sh_log_send_string("\n");
sh_log_llog("Total memory taken by physical bitmap (bytes) : ",source);
sh_log_send_uintn(mem_stats.physical_bitmap_size_bytes);
sh_log_send_string(" / 0x");
sh_log_send_uintn_hex(mem_stats.physical_bitmap_size_bytes);
sh_log_send_string("\n");
sh_log_llog("Total memory taken by physical bitmap (pages) : ",source);
sh_log_send_uintn(mem_stats.physical_bitmap_size_pages);
sh_log_send_string(" / 0x");
sh_log_send_uintn_hex(mem_stats.physical_bitmap_size_pages);
sh_log_send_string("\n");
}
return SH_STATUS_SUCCESS;
}