raeofsunshine
/
KimisOS
mirror of https://github.com/raeofsunshinedev/KimisOS.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed kstdlib.c:vector_push, implemented modules.c:dispatch_message()

This commit is contained in:
notsomeidiot123 2026-03-02 23:12:01 -05:00
parent 0e96dfd969
commit 0f9a174d0e
10 changed files with 129 additions and 75 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
docs/messages.md Normal file
View File

@ -0,0 +1,5 @@
# Kernel Messages
Messages are one-way generic communication system from the kernel to modules. It's designed to support a first-come, first-serve approach to handling of tasks like filesystem mounting, while also supporting broadcast style messages (e.g. a shutdown), that applies to every module with a listener.
Modules are not required to provide a handler, nor support all types of messages. However, modules with handlers are expected to return `-1` in the event of a failure, or if the message dispatched is not supported.

26
docs/modules.md
View File

@ -151,3 +151,29 @@ Arguments: `uint32_t key, void (*handler)(uint32_t message, ...)`
Assigns and marks valid message handler to recieve messages from the kernel to kernel modules. Returns -1 if the key is invalid, otherwise, returns 0. No messages have been implemented, but a will update with a table of messages as necessary.
If a message handler cannot handle a message, it is required that the message handler returns -1.
#### MODULE_API_BLOCK_PID
Arguments: `uint32_t pid`
Sets the process `pid` as blocked, and will not run until set unblocked.
#### MODULE_API_UNBLOCK_PID
Arguments: `uint32_t pid`
Sets the process `pid` as unblocked, and will resume execution after the current queue has finished executing.
#### MODULE_API_GET_CPID
Arguments:
Obtains the ID of the current executing process.
#### MODULE_API_GET_INTERRUPT
Arguments:
Asks the interrupt handler whether or not it considers itself to be in an interrupt. Returns 1 if true.
Deprecated, but probably won't be removed for now.

7
docs/syscalls.md Normal file
View File

@ -0,0 +1,7 @@
# System Calls
System calls are executed by calling `int 0x80` with `eax` equal to the number of the system call you are executing. Arguments to system calls are stored in the other general purpose registers. The meaning of each register for each system call can be seen in the system call table. (TODO: Implement system calls)
|Name|EAX|EBX|ECX|EDX|ESI|EDI|
|----|---|---|---|---|---|---|
|Exit|0 | Exit_code|-|-|-|-|

1
src/kernel/kmain.c
View File

@ -38,6 +38,7 @@ void sysinit(){
mlog("KERNEL", "Filename: %s\n", MLOG_PRINT, dir_data[i]->name);
vfs_detect_partitions(dir_data[i]);
}
dispatch_message(0);
printf("Bleh\n");
//why did i stop working on this? what was wrong with this?
for(;;);

21
src/kernel/shared/kstdlib.c
View File

@ -37,7 +37,7 @@ vector_t *init_vector(void *vecptr, uint32_t sizeof_elements, uint32_t elements,
ret->sizeof_elements = sizeof_elements;
ret->size = elements;
uint32_t pages = (elements * sizeof_elements)/4096 + 1;
if(elements > 0) ret->ptr = kmalloc(pages);
ret->ptr = kmalloc(pages);
if(initializer == 0) return ret;
for(uint8_t i = 0; i < elements * sizeof_elements; i++){
((uint8_t *)(ret->ptr))[i] = ((uint8_t *)initializer)[i];
@ -46,19 +46,20 @@ vector_t *init_vector(void *vecptr, uint32_t sizeof_elements, uint32_t elements,
}
void *vector_get(uint32_t pos, vector_t *vector){
if(pos > vector->size){
if(pos > vector->size - 1){
return 0;
}
// printf("Vector: %x, pos: %x, sizeof: %x, return: %x", vector->ptr, pos, vector->sizeof_elements, vector->ptr + (pos*vector->sizeof_elements));
return vector->ptr + (pos*vector->sizeof_elements);
}
//pos MUST be within vector bounds;
void vector_set(uint32_t pos, vector_t *vector, void *new_element){
if(pos > vector->size){
if(pos > vector->size - 1){
return;
}
for(uint32_t i = 0; i < vector->sizeof_elements; i++){
((uint8_t *)(vector->ptr))[i] = ((uint8_t *)new_element)[i];
((uint8_t *)(vector->ptr + pos * sizeof(void *)))[i] = ((uint8_t *)new_element)[i];
}
}
// void vector_push(vector_t *vector, void *new_element){
@ -74,15 +75,19 @@ void vector_set(uint32_t pos, vector_t *vector, void *new_element){
// }
// printf(" (vector push ) %d", vector->size);
// }
void vector_push(vector_t *vector, void *new_element){
if(((vector->size + 1) * vector->sizeof_elements) >> 12 != (vector->size * vector->sizeof_elements)){
if(((vector->size + 1) * vector->sizeof_elements) >> 12 != (vector->size * vector->sizeof_elements) >> 12){
void *newptr = kmalloc((vector->size * vector->sizeof_elements)/4096);
for(uint8_t i = 0; i < (vector->size - 1) * vector->sizeof_elements; i++){
((uint8_t *)(newptr))[i] = ((uint8_t *)vector->ptr)[i * vector->size];
if(vector->ptr){
for(uint8_t i = 0; i < (vector->size - 1) * vector->sizeof_elements; i++){
((uint8_t *)(newptr))[i] = ((uint8_t *)vector->ptr)[i * vector->size];
}
}
}
for(uint32_t i = 0; i < vector->sizeof_elements; i++){
((uint8_t *)(vector->ptr))[vector->size + i] = ((uint8_t *)new_element)[i];
((uint8_t *)(vector->ptr))[vector->size * vector->sizeof_elements + i] = ((uint8_t *)new_element)[i];
}
vector->size++;
}

36
src/kernel/system/modules.c
View File

@ -24,11 +24,11 @@ uint32_t module_api(uint32_t func, ...){
}
uint32_t tmp = pm_alloc();
(structure->key) = (modules->size ^ 190507) + tmp << 12 ^ 4405648937 ^ 8592807313 >> 5;
structure->key &= 0xffffff00 | modules->size;
structure->key &= (0xffffff00 | modules->size);
vector_push(modules, structure);
pm_free(tmp);
return_value = 0;
// printf("vector size -> %d", structure->key);
// printf("Registered Key: %x", structure->key);
break;
case MODULE_API_ADDINT:
uint32_t int_index = va_arg(vars, uint32_t);
@ -132,6 +132,7 @@ uint32_t module_api(uint32_t func, ...){
for(int i = 0; i < modules->size; i++){
module_t* module = ((module_t *)vector_get(i, modules));
if(module->key == key){
// printf("Adding message handler!!\n\n");
module->message_handler = handler;
return_value = 0;
break;
@ -158,10 +159,41 @@ uint32_t module_api(uint32_t func, ...){
return return_value;
}
void dispatch_message(uint32_t message, ...){
va_list args;
va_start(args, message);
for(int i = 0; i < modules->size; i++){
module_t *module = vector_get(i, modules);
// int32_t (*handler)(uint32_t, ...) = ((module_t *)(vector_get(i, modules)))->key;
// uint32_t key = ((module_t *)(vector_get(i, modules)))->key;
uint32_t key = module->key;
int32_t (*handler)(uint32_t, ...) = module->message_handler;
if(!handler) continue;
// printf("Handler: %x, Key: %x\n", handler, key);
// for(;;);
int32_t result = 0;
vfile_t *srcfile;
char *destname;
uint32_t offset;
switch(message){
case MESSAGE_MOUNT_FS:
srcfile = va_arg(args, vfile_t *);
destname = va_arg(args, char *);
offset = va_arg(args, uint32_t);
result = handler(message, srcfile, destname, offset);
break;
}
if((int32_t) message > 0 && result){
break;
}
}
va_end(args);
}

14
src/kernel/system/modules.h
View File

@ -38,14 +38,22 @@ enum MODULE_API_FUNCS{
MODULE_API_IS_INTERRUPT,
};
enum MESSAGES{
MESSAGE_MOUNT_FS,
MESSAGE_UNMOUNT_FS,
MESSAGE_BROADCAST = 0x80000000, //placeholder
};
void dispatch_message(uint32_t message, ...);
typedef struct module{
void *init_entry;
uint32_t id;
char name[16];
uint8_t flags;
uint16_t interrupts;
// uint8_t flags;
uint32_t interrupts;
uint32_t key;
void (*message_handler)(uint32_t message, ...);
int32_t (*message_handler)(uint32_t message, ...);
void (*fini)(void);
}module_t;

36
src/kmodules/disk_driver.c
View File

@ -114,7 +114,7 @@ typedef struct PRD{
module_t module_data = {
init,
0xfae00000,
MODULE_NAME,
"KIDM ",
0,
0,
0,
@ -163,9 +163,8 @@ void ata_acquire_primary_lock(){
asm("cli");
while(primary_ata_locked){
asm("sti");
// puts(api, "KIDM", "Locked\n");
asm("int $32");
asm("cli");
asm("cli\nmfence");
}
primary_ata_locked = 1;
asm("sti");
@ -207,8 +206,6 @@ uint32_t find_free_drive(){
int ata_write(vfile_t *file, void *ptr, uint32_t offset, uint32_t count){
if (count == 0) return -1;
// while(transferring_disk_index != -1);
// if(!is_interrupt(api)){
ata_acquire_primary_lock();
// }
drive_t drive = drives[file->mount_id];
@ -273,6 +270,8 @@ int ata_write(vfile_t *file, void *ptr, uint32_t offset, uint32_t count){
expected_ints = pages;
recieved_ints = 0;
asm("cli");
uint32_t cpid = api(MODULE_API_GET_CPID);
api(MODULE_API_PRINT, MODULE_NAME, "Cpid: %x", cpid);
api(MODULE_API_BLOCK_PID, cpid);
@ -280,22 +279,13 @@ int ata_write(vfile_t *file, void *ptr, uint32_t offset, uint32_t count){
outb(bm_base, 0x01);
asm("sti");
transferring_disk_index = file->mount_id;
uint8_t status = inb(ctrl_base);
uint8_t bm_status = inb(bm_base + 2);
// api(MODULE_API_PRINT, MODULE_NAME, "Status: (ATA)%x, (Busmaster)%x\n", status, bm_status);
// if(ATA_ABRT(status)){
// puts(api, MODULE_NAME, "Command aborted\n");
// return -1;
// }
// while (transferring_disk_index != -1);
//!TODO! SUPER IMPORTANT!!!! MARK CURRENT THREAD AS BLOCKED AND RE-ENTER AFTER IRQ IS FIRED
// while(ATA_BSY(status)){
// status = inb(io_base + ATA_STATUS);
// }
// if(!is_interrupt){
asm("int $32\n");
// }
@ -370,6 +360,7 @@ int ata_read(vfile_t *file, uint8_t *ptr, uint32_t offset, uint32_t count) {
expected_ints = pages;
recieved_ints = 0;
asm("cli");
transferring_disk_index = file->mount_id;
uint32_t cpid = api(MODULE_API_GET_CPID);
// api(MODULE_API_PRINT, MODULE_NAME, "Cpid: %x", cpid);
@ -377,7 +368,7 @@ int ata_read(vfile_t *file, uint8_t *ptr, uint32_t offset, uint32_t count) {
transferring_pid = cpid;
outb(bm_base, 0x09);
asm("sti");
uint8_t status = inb(ctrl_base);
uint8_t bm_status = inb(bm_base + 2);
@ -386,15 +377,7 @@ int ata_read(vfile_t *file, uint8_t *ptr, uint32_t offset, uint32_t count) {
// puts(api, MODULE_NAME, "Command aborted\n");
// return -1;
// }
// while (transferring_disk_index != -1);
// while(ATA_BSY(status)){
// status = inb(io_base + ATA_STATUS);
// }
// outb(bm_base, 0x00);
// if(!is_interrupt){
asm("int $32\n");
// }
return 0;
}
@ -595,6 +578,7 @@ void init(KOS_MAPI_FP module_api, uint32_t api_version){
api(MODULE_API_PRINT, MODULE_NAME, "Failed to register module, exiting\n");
return;
}
api(MODULE_API_PRINT, MODULE_NAME, "Assigned Key: %x\n", module_data.key);
api(MODULE_API_ADDINT, 15, module_data.key, int_handler);
api(MODULE_API_ADDINT, 14, module_data.key, int_handler);
// api(MODULE_API_ADDINT, 0, module_data.key, int_handler);

50
src/kmodules/fs_driver.c
View File

@ -6,44 +6,26 @@
KOS_MAPI_FP api;
void init(KOS_MAPI_FP module_api, uint32_t api_version);
module_t module_data = {
init,
0xfae00001,
MODULE_NAME,
0,
0,
0,
};
// void mount_fat32(vfile_t *dev_file, char *destination){
// }
int callback(vfile_t *device, MOUNT_OPERATION op, ...){
if(op == MOUNT_NEW){
//call mount functions to try and
}
int32_t message_handler(uint32_t message, ...){
puts(api, MODULE_NAME, "Called message handler!\n");
return -1;
}
//buffer is a pointer to a string that contains the filename, followed by a comma, followed by the mount destination. If there is no destination [i.e. no comma], command will be treated as unmount
int mount(vfile_t *file, char *buffer, uint32_t offset, uint32_t count){
char filename_buffer[256];
char destination_buffer[256];
uint32_t comma_offset = 0;
int i = 0;
for(; i < 256; i++){
if(buffer[i] == ',' || !buffer[i]){
break;
}
filename_buffer[i] = buffer[i];
}
filename_buffer[i] = 0;
comma_offset = i + 1;
i = 0;
for(; i < 256; i++){
if(buffer[i] == 0){
break;
}
destination_buffer[i] = buffer[i];
}
destination_buffer[i] = 0;
vfile_t *src = fget_file(api, filename_buffer);
if(!src){
puts(api, MODULE_NAME, "src does not exist\n");
}
return 0;
}
int phony_read(vfile_t *file, char*buffer, uint32_t offset, uint32_t count){
return 0;
}
@ -52,6 +34,10 @@ int phony_read(vfile_t *file, char*buffer, uint32_t offset, uint32_t count){
void init(KOS_MAPI_FP module_api, uint32_t api_version){
api = module_api;
api(MODULE_API_PRINT, MODULE_NAME, "KIFSM Filesystem Driver Module v0.1.0\nSupported Filesystems:\n");
int32_t status = api(MODULE_API_REGISTER, &module_data);
api(MODULE_MESSAGE_HANDLER, module_data.key, message_handler);
api(MODULE_API_PRINT, MODULE_NAME, "Key: %x\n", module_data.key);
return;
}

8
src/kmodules/modlib.h
View File

@ -33,12 +33,12 @@ typedef struct module{
void *init_entry;
uint32_t id;
char name[16];
uint8_t flags;
uint16_t interrupts;
// uint8_t flags;
uint32_t interrupts;
uint32_t key;
void (*message_handler)(uint32_t message, ...);
int32_t (*message_handler)(uint32_t message, ...);
void (*fini)(void);
}module_t;
} module_t;
typedef struct cpu_registers{
uint32_t gs, fs, es, ds;