237 lines
8.6 KiB
C
237 lines
8.6 KiB
C
#include "kernel.h"
|
|
|
|
// This only runs once and from there on forth only interrupts will cause something to happen
|
|
// e.g. displaying to screen and taking input from keyboard
|
|
void _start() {
|
|
// Initialize Global Variables and set up interrrupt handlers
|
|
// These variables are a vulnerability to OS security if someone can adjust
|
|
// the lower value in the kernel code (exploiting, for example, an Intel address hack)
|
|
// than kernel memory and even kernel code can be overwritten
|
|
// https://www.wired.com/story/intel-lab-istare-hack-chips/
|
|
// See libc/globals.h for KMEM_START and KMEM_END values
|
|
// See libc/globals.h for UMEM_START and UMEM_END values
|
|
kmem_addr = KMEM_START;
|
|
kernel_mem_limit = KMEM_END;
|
|
|
|
umem_addr = UMEM_START;
|
|
user_mem_limit = UMEM_END;
|
|
|
|
global_head = NULL;
|
|
global_id = 0;
|
|
|
|
|
|
isr_install();
|
|
irq_install();
|
|
|
|
kprint("Type something, it will go through the kernel\n"
|
|
"Type HELP to list commands\n> ");
|
|
}
|
|
|
|
// An interrupt calls this function to parse what was typed in, this is, essentially, your
|
|
// Command Line Interpreter for now.
|
|
void user_input(char *input) {
|
|
static u32 delete_id = 0; // static persistent variable for incrementing during test
|
|
static node* umem_head = NULL; // static persistent head variable for contiguous block allocations
|
|
if (strcmp(input, "END") == 0) {
|
|
kprint("Stopping the CPU. Bye!\n");
|
|
asm volatile("hlt");
|
|
} else if (strncmp(input, "ADD", 3) == 0) {
|
|
u32 base = 0x10000;
|
|
u32 limit = 0x100;
|
|
bool valid = true;
|
|
if (sstrlen(input, 15) > 4) {
|
|
char *args1 = input + 4;
|
|
base = digit_conver(args1);
|
|
int nDigits = digit_len(base);
|
|
if (sstrlen(args1, 15) > nDigits + 1) {
|
|
char *args2 = args1 + nDigits + 1;
|
|
limit = digit_conver(args2);
|
|
if (limit < 100) {
|
|
kprint("That memory address is to below the min of 0x100.\n");
|
|
valid = false;
|
|
}
|
|
}
|
|
if (base < 10000) {
|
|
kprint("That memory address is reserved by the Kernel, addresses must be 10000+\n");
|
|
valid = false;
|
|
}
|
|
}
|
|
if (valid) {
|
|
umem_head = add_node( umem_head, base, limit-1, true, global_id++);
|
|
}
|
|
} else if (strcmp(input, "LIST") == 0) {
|
|
kprint("***** FORWARD ****\n");
|
|
print_list( umem_head, true);
|
|
kprint("***** REVERSE ****\n");
|
|
print_list( umem_head, false);
|
|
} else if (strcmp(input, "SHORTLIST") == 0) {
|
|
shortprint_list( umem_head, true);
|
|
kprint("\n******************\n");
|
|
shortprint_list( umem_head, false);
|
|
} else if (strcmp(input, "PAGE") == 0) {
|
|
u32 phys_addr = 0;
|
|
u32 page = umalloc(0x4200, 0, &phys_addr);
|
|
kprint_hex( "Page: ", page, 10);
|
|
kprint_hex(", physical address: ", phys_addr, 10);
|
|
kprint("\n");
|
|
} else if (strcmp(input, "DELETE") == 0) {
|
|
umem_head = remove_node_by_id( umem_head, delete_id++);
|
|
} else if (strcmp(input, "INSERT") == 0) {
|
|
node *new_node = create_node( 0x15000, 0x1100, true, global_id++);
|
|
node *insert_point = find_id( umem_head, 3);
|
|
umem_head = insert_node( umem_head, insert_point, new_node, true);
|
|
new_node = create_node( 0x18000, 0x2100, true, global_id++);
|
|
insert_point = find_id( umem_head, 5);
|
|
umem_head = insert_node( umem_head, insert_point, new_node, false);
|
|
} else if (strcmp(input, "SORTA") == 0) {
|
|
umem_head = hacksort_list( umem_head, true);
|
|
} else if (strcmp(input, "SORTD") == 0) {
|
|
umem_head = hacksort_list( umem_head, false);
|
|
} else if (strcmp(input, "SWAP") == 0) {
|
|
node *n1 = find_id( umem_head, 1);
|
|
node *n2 = find_id( umem_head, 5);
|
|
node *n3 = find_id( umem_head, 3);
|
|
node *n4 = find_id( umem_head, 7);
|
|
swap_node_data( n1, n2);
|
|
swap_node_data( n2, n3);
|
|
swap_node_data( n3, n4);
|
|
} else if (strcmp(input, "TEST") == 0) {
|
|
char s1[10] = "ABCDFFGH\0";
|
|
char s2[10] = "ABCDEGH\0";
|
|
int x = strncmp( s1, s2, 5);
|
|
kprint_hex( "STRNCMP: ", x, 16);
|
|
kprint("\n");
|
|
|
|
x = sstrlen( s2, 10);
|
|
kprint_hex( "SSTRLEN: ", x, 10);
|
|
kprint("\n");
|
|
|
|
x = strlen( s2);
|
|
kprint_hex( "STRLEN: ", x, 10);
|
|
kprint("\n");
|
|
} else if (strcmp(input, "HELP") == 0) {
|
|
kprint("Current Commands: ADD, LIST, SHORTLIST, PAGE, DELETE,\n");
|
|
kprint(" : END, INSERT, SORTA, SORTD, SWAP, TEST, HELP\n");
|
|
kprint(" Review the kernel.c source code to see what each command does.\n");
|
|
kprint(" These are hard coded and are just examples, modify as you see fit.\n");
|
|
kprint(" for example - TEST was just added so that I could test the strlen commands.\n");
|
|
} else if (strcmp(input, "HOLES") == 0) {
|
|
node *holes = get_holes(umem_head);
|
|
print_list( holes, false);
|
|
} else if (strcmp(input, "RESULT") == 0) {
|
|
node *holes = get_holes( umem_head);
|
|
print_memory( umem_head, holes);
|
|
} else {
|
|
kprint("You said: ");
|
|
kprint(input);
|
|
kprint("\n");
|
|
}
|
|
kprint("> ");
|
|
}
|
|
|
|
int digit_len(unsigned digit) {
|
|
if (digit >= 1000000000) return 10;
|
|
if (digit >= 100000000) return 9;
|
|
if (digit >= 10000000) return 8;
|
|
if (digit >= 1000000) return 7;
|
|
if (digit >= 100000) return 6;
|
|
if (digit >= 10000) return 5;
|
|
if (digit >= 1000) return 4;
|
|
if (digit >= 100) return 3;
|
|
if (digit >= 10) return 2;
|
|
return 1;
|
|
}
|
|
|
|
int digit_conver(const char *hexString) {
|
|
u32 result = 0;
|
|
while (*hexString != '\0') {
|
|
char hexChar = *hexString;
|
|
if ((hexChar >= '0' && hexChar <= '9') || (hexChar >= 'A' && hexChar <= 'F')) {
|
|
int digit = (hexChar >= '0' && hexChar <= '9') ? (hexChar - '0') : (10 + (hexChar - 'A'));
|
|
result = result * 16 + digit;
|
|
} else {
|
|
break;
|
|
}
|
|
hexString++;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
|
|
void print_memory(node *umem_head, node *hole_head) {
|
|
|
|
u32 total_memory = 0x3FFFF;
|
|
u32 free_memory = total_memory;
|
|
|
|
int num_of_gaps = 0;
|
|
int num_of_nodes = 0;
|
|
while (umem_head != NULL) {
|
|
num_of_nodes++;
|
|
free_memory = free_memory - umem_head->limit_register;
|
|
umem_head = umem_head->next;
|
|
}
|
|
|
|
while (hole_head != NULL) {
|
|
num_of_gaps++;
|
|
hole_head = hole_head->next;
|
|
}
|
|
|
|
u32 total_allocated = total_memory - free_memory;
|
|
total_memory = ((total_memory+1)-64)/(0x400);
|
|
char a[16];
|
|
int_to_ascii( total_memory, a, 16);
|
|
kprint("\nTotal Physical Memory: ");
|
|
kprint(a);
|
|
kprint("kb\n");
|
|
|
|
free_memory = ((free_memory+1)-64)/(0x400);
|
|
char b[16];
|
|
int_to_ascii( free_memory, b, 16);
|
|
kprint("Total Free: ");
|
|
kprint(b);
|
|
kprint("kb\n");
|
|
|
|
total_allocated = ((total_allocated+1)-64)/(0x400);
|
|
char c[16];
|
|
int_to_ascii( total_allocated, c, 16);
|
|
kprint("Total Allocated: ");
|
|
kprint(c);
|
|
kprint("kb\n");
|
|
|
|
char d[16];
|
|
int_to_ascii( num_of_nodes, d, 16);
|
|
kprint("Number of Allocations: ");
|
|
kprint(d);
|
|
kprint("\n");
|
|
|
|
char e[16];
|
|
int_to_ascii( num_of_gaps, e, 16);
|
|
kprint("Number of Free Gaps: ");
|
|
kprint(e);
|
|
kprint("\n");
|
|
|
|
kprint("Start of Memory: 0x10000\nEnd of Memory: 0xFFFFF\n");
|
|
}
|
|
|
|
node* get_holes(node* umem_head) {
|
|
if (umem_head == NULL) {
|
|
kprint("Holes list is Empty\n");
|
|
return NULL;
|
|
}
|
|
u32 hole_ids = 0;
|
|
node *hole = NULL;
|
|
if (umem_head->base_register-0x10000 != 0) {
|
|
hole = add_node( hole, 0x10000, umem_head->base_register-0x10000-1, true, ++hole_ids);
|
|
}
|
|
while(umem_head != NULL) {
|
|
if (umem_head->next != NULL) {
|
|
node *next = umem_head->next;
|
|
u32 total = umem_head->base_register+umem_head->limit_register;
|
|
hole = add_node( hole, total, next->base_register-total-1, true, ++hole_ids);
|
|
} else {
|
|
hole = add_node( hole, umem_head->base_register+umem_head->limit_register-1, 0x3FFFF, true, ++hole_ids);
|
|
}
|
|
umem_head = umem_head->next;
|
|
}
|
|
return hole;
|
|
} |