Wie kann ich meinem Mini-Betriebssystemkernel ein einfaches Dateisystem hinzufügen? [geschlossen]

Anonymous · Post by **Anonymous** » 20 Dec 2025, 19:21

Ich möchte dem Kernel meines Betriebssystems ein Dateisystem (FS) hinzufügen, einige davon sind einfach, nicht wie ext4. Mein Betriebssystem verfügt über ein I/O-System.
Was ich dazu wissen muss und welches einfache FS existiert?
C-Kernel:

Code: Select all

#include "keyboard_map.h"

/* there are 25 lines each of 80 columns; each element takes 2 bytes */
#define LINES 25
#define COLUMNS_IN_LINE 80
#define BYTES_FOR_EACH_ELEMENT 2
#define SCREENSIZE BYTES_FOR_EACH_ELEMENT * COLUMNS_IN_LINE * LINES

#define KEYBOARD_DATA_PORT 0x60
#define KEYBOARD_STATUS_PORT 0x64
#define IDT_SIZE 256
#define INTERRUPT_GATE 0x8e
#define KERNEL_CODE_SEGMENT_OFFSET 0x08

#define ENTER_KEY_CODE 0x1C

extern unsigned char keyboard_map[128];
extern void keyboard_handler(void);
extern char read_port(unsigned short port);
extern void write_port(unsigned short port, unsigned char data);
extern void load_idt(unsigned long *idt_ptr);

/* current cursor location */
unsigned int current_loc = 0;
/* video memory begins at address 0xb8000 */
char *vidptr = (char*)0xb8000;

struct IDT_entry {
unsigned short int offset_lowerbits;
unsigned short int selector;
unsigned char zero;
unsigned char type_attr;
unsigned short int offset_higherbits;
};

struct IDT_entry IDT[IDT_SIZE];

void idt_init(void)
{
unsigned long keyboard_address;
unsigned long idt_address;
unsigned long idt_ptr[2];

/* populate IDT entry of keyboard's interrupt */
keyboard_address = (unsigned long)keyboard_handler;
IDT[0x21].offset_lowerbits = keyboard_address & 0xffff;
IDT[0x21].selector = KERNEL_CODE_SEGMENT_OFFSET;
IDT[0x21].zero = 0;
IDT[0x21].type_attr = INTERRUPT_GATE;
IDT[0x21].offset_higherbits = (keyboard_address & 0xffff0000) >> 16;

/*     Ports
*    PIC1   PIC2
*Command 0x20   0xA0
*Data    0x21   0xA1
*/

/* ICW1 - begin initialization */
write_port(0x20 , 0x11);
write_port(0xA0 , 0x11);

/* ICW2 - remap offset address of IDT */
/*
* In x86 protected mode, we have to remap the PICs beyond 0x20 because
* Intel have designated the first 32 interrupts as "reserved" for cpu exceptions
*/
write_port(0x21 , 0x20);
write_port(0xA1 , 0x28);

/* ICW3 - setup cascading */
write_port(0x21 , 0x00);
write_port(0xA1 , 0x00);

/* ICW4 - [url=viewtopic.php?t=25360]environment[/url] info */
write_port(0x21 , 0x01);
write_port(0xA1 , 0x01);
/* Initialization finished */

/* mask interrupts */
write_port(0x21 , 0xff);
write_port(0xA1 , 0xff);

/* fill the IDT descriptor */
idt_address = (unsigned long)IDT ;
idt_ptr[0] = (sizeof (struct IDT_entry) * IDT_SIZE) + ((idt_address & 0xffff) > 16 ;

load_idt(idt_ptr);
}

void kb_init(void)
{
/* 0xFD is 11111101 - enables only IRQ1 (keyboard)*/
write_port(0x21 , 0xFD);
}

void kprint(const char *str)
{
unsigned int i = 0;
while (str[i] != '\0') {
vidptr[current_loc++] = str[i++];
vidptr[current_loc++] = 0x07;
}
}

void kprint_newline(void)
{
unsigned int line_size = BYTES_FOR_EACH_ELEMENT * COLUMNS_IN_LINE;
current_loc = current_loc + (line_size - current_loc % (line_size));
}

void clear_screen(void)
{
unsigned int i = 0;
while (i < SCREENSIZE) {
vidptr[i++] = ' ';
vidptr[i++] = 0x07;
}
}

void keyboard_handler_main(void)
{
unsigned char status;
char keycode;

/* write EOI */
write_port(0x20, 0x20);

status = read_port(KEYBOARD_STATUS_PORT);
/* Lowest bit of status will be set if buffer is not empty */
if (status & 0x01) {
keycode = read_port(KEYBOARD_DATA_PORT);
if(keycode <  0)
return;

if(keycode == ENTER_KEY_CODE) {
kprint_newline();
return;
}

vidptr[current_loc++] = keyboard_map[(unsigned char) keycode];
vidptr[current_loc++] = 0x07;
}
}

// main
void kmain(void)
{
const char *str = "my kernel with keyboard support";
clear_screen();
kprint(str);
kprint_newline();
kprint_newline();

idt_init();
kb_init();

while(1);
}

Tastaturbelegung sieht so aus:

Code: Select all

unsigned char keyboard_map[128] =
{
0,  27, '1', '2', '3', '4', '5', '6', '7', '8', /* 9 */
'9', '0', '-', '=', '\b', /* Backspace */
'\t',         /* Tab */
'q', 'w', 'e', 'r',   /* 19 */
't', 'y', 'u', 'i', 'o', 'p', '[', ']', '\n', /* Enter key */
0,          /* 29   - Control */
'a', 's', 'd', 'f', 'g', 'h', 'j', 'k', 'l', ';', /* 39 */
'\'', '`',   0,        /* Left shift */
'\\', 'z', 'x', 'c', 'v', 'b', 'n',            /* 49 */
'm', ',', '.', '/',   0,              /* Right shift */
'*',
0,  /* Alt */
' ',  /* Space bar */
0,  /* Caps lock */
0,  /* 59 - F1 key ... > */
0,   0,   0,   0,   0,   0,   0,   0,
0,  /* < ... F10 */
0,  /* 69 - Num lock*/
0,  /* Scroll Lock */
0,  /* Home key */
0,  /* Up Arrow */
0,  /* Page Up */
'-',
0,  /* Left Arrow */
0,
0,  /* Right Arrow */
'+',
0,  /* 79 - End key*/
0,  /* Down Arrow */
0,  /* Page Down */
0,  /* Insert Key */
0,  /* Delete Key */
0,   0,   0,
0,  /* F11 Key */
0,  /* F12 Key */
0,  /* All other keys are undefined */
};

und die Assembly-Datei meines Kernels:

Code: Select all

bits 32
section .text
;multiboot spec
align 4
dd 0x1BADB002              ;magic
dd 0x00                    ;flags
dd - (0x1BADB002 + 0x00)   ;checksum. m+f+c should be zero

global start
global keyboard_handler
global read_port
global write_port
global load_idt

extern kmain        ;this is defined in the c file
extern keyboard_handler_main

read_port:
mov edx, [esp + 4]
;al is the lower 8 bits of eax
in al, dx   ;dx is the lower 16 bits of edx
ret

write_port:
mov   edx, [esp + 4]
mov   al, [esp + 4 + 4]
out   dx, al
ret

load_idt:
mov edx, [esp + 4]
lidt [edx]
sti                 ;turn on interrupts
ret

keyboard_handler:
call    keyboard_handler_main
iretd

start:
cli                 ;block interrupts
mov esp, stack_space
call kmain
hlt                 ;halt the CPU

section .bss
resb 8192; 8KB for stack
stack_space:

link.ld:

Code: Select all

OUTPUT_FORMAT(elf32-i386)
ENTRY(start)
SECTIONS
{
. = 0x100000;
.text : { *(.text) }
.data : { *(.data) }
.bss  : { *(.bss)  }
}

Und übrigens, wie funktioniert FS? (Ich weiß, welche FS Festplatten, Dateien, Verzeichnisse und eine andere Basis haben).
Sie können es unter Linux erstellen mit:

1.

Code: Select all