SingOS/lsfs_16-bit
3
0 Fork 0
Code Issues Pull Requests Releases Wiki Activity

Defeated 16-bit, we can now load the kernel by path

Browse Source
This commit is contained in:
Jørn Guldberg committed 2019-06-30 20:46:39 +00:00
1 parent ec61cd8b8a
commit a6a338c17a
11 files changed
+6063 -1047
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

build.sh
+1 -1
View File
@@ -1,4 +1,4 @@
bcc -S main.c implementation/lsfs.c
bcc -S main.c -o main.s
echo -e "push bp
mov bp,sp
push 10[bp]
disk.out
BIN
View File
Binary file not shown.
driver/disk.h
+11 -5
View File
@@ -2,30 +2,36 @@ int data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment);
int disk_service_read_data_from_disk(index, number_sectors, data_buffer, data_buffer_segment)
long* index;
long index;
long number_sectors;
void* data_buffer;
int data_buffer_segment;
unsigned int data_buffer_segment;
{
#asm
#define index 4[bp]; // Note that this is a 32-bit argument.
#define number_sectors 8[bp];
#define data_buffer 10[bp];
#define data_buffer_segment 12[bp];
#define data_buffer 12[bp];
#define data_buffer_segment 14[bp];
push bp
mov bp,sp
pusha
lsfs_load_data:
mov ax, index
call 0x0000:0x7C2A
mov WORD [DAPACK.lba_addr_dw_low], ax
mov bx, number_sectors
mov ax, bx
call 0x0000:0x7C2A
mov WORD [DAPACK.blkcnt], bx
mov cx, data_buffer_segment
mov ax, cx
call 0x0000:0x7C2A
mov WORD [DAPACK.db_addr_segment], cx
mov dx, data_buffer;
mov ax, dx
call 0x0000:0x7C2A
mov WORD [DAPACK.db_addr_offset], dx
mov si, #DAPACK ; address of
mov ah, #0x42 ; READ
implementation/lsfs.c
+81 -22
View File
@@ -1,26 +1,81 @@
#include "lsfs.h"
#include "../main.h"
/* #include "../std_singos/string.h" */
extern FSCI fsci;
struct lsfs_file {
long file_id[2];
long table_entry_pointer[2];
Table_Entry_Kind entry_kind;
char* filename;
long owner_id;
long size[2];
long creation_date[2];
long access_time[2];
long modification_time[2];
long number_sector;
long table_entry_sector_index[2];
long data_pointer[NUM_DATA_POINTERS * 2];
};
int lsfs_disk_getattr(find_file, path)
lsfs_file* find_file;
char* path;
{
int i;
String_Array *split_path = string_split_c(path, '/', false);
Length_String *filename = split_path->strings[split_path->length-1];
int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry)
/* Start from the master table*/
Directory_Table *dir_table = lsfs_find_directory(path, true);
for (i = 0; i < DEFAULT_TABLE_SIZE; ++i)
{
if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
find_file->file_id[0] = dir_table->entries[i].file_id;
find_file->entry_kind = dir_table->entries[i].entry_kind;
find_file->table_entry_pointer[0] = i;
find_file->filename = dir_table->entries[i].filename;
find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
find_file->owner_id = 1;
find_file->size[0] = dir_table->entries[i].file_size; /* dir_table->entries[i].data_pointer[0]; ;*/
find_file->creation_date[0] = 0;
find_file->access_time[0] = 0;
find_file->modification_time[0] = 0;
memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, NUM_DATA_POINTERS * 8);
find_file->number_sector = 1; /* TODO: should be loaded from disk.*/
return 1;
}
}
return 0;
}
Directory_Table* lsfs_find_directory(path, drop_filename)
char *path;
short drop_filename;
{
int number_of_traversal;
int i, j;
String_Array *split_path;
Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
/* printf("Table index: %lu \n",fsci.master_table_index ); */
disk_service_read_data_from_disk(fsci.master_table_index[0], DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
split_path = string_split_c(path, '/', false);
number_of_traversal = split_path->length;
if (drop_filename)
{
number_of_traversal -= 1;
}
/* Start from the master table */
for (i = 0; i < number_of_traversal; ++i)
{
for (j = 0; j < DEFAULT_TABLE_SIZE; ++j)
{
if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
{
int index_sector = dir_table->entries[j].data_pointer[0];
/* printf("Table index: %lu \n",index_sector ); */
disk_service_read_data_from_disk(index_sector, DEFAULT_TABLE_SIZE, dir_table);
break;
}
}
}
return dir_table;
}
int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment)
lsfs_file *file;
int buffer_size;
char *data;
long offset_to_next_entry;
unsigned int data_segment;
{
int integer_file_size = file->size;
int integer_offset = offset_to_next_entry;
@@ -36,6 +91,7 @@ long offset_to_next_entry;
int data_pointer_index = 0; /* start at first data pointer. */
dump_ax(file->size);
if (data_length > buffer_size)
{
data_length = buffer_size;
@@ -63,11 +119,14 @@ long offset_to_next_entry;
{
break;
}
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer);
memcpy((data + amount_read), tmp_buffer, amount_to_read);
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
print_newline();
dump_ax(file->data_pointer[data_pointer_index]);
print_newline();
memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read);
data_length -= amount_to_read;
amount_read += amount_to_read;
data_pointer_index++;
data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
/* free(tmp_buffer); */
}
else if (remaining_offset < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE))
@@ -84,14 +143,14 @@ long offset_to_next_entry;
amount_to_read = ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset);
}
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer);
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
memcpy(data, (tmp_buffer + remaining_offset), amount_to_read);
memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
data_length -= amount_to_read;
amount_read += amount_to_read;
remaining_offset -= amount_to_read;
data_pointer_index++;
data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
/* free(tmp_buffer); */
}
else
implementation/lsfs.h
+274
View File
@@ -1,6 +1,280 @@
#ifndef LSFS_H
#define LSFS_H
#include "../main.h"
typedef struct lsfs_file lsfs_file;
typedef struct Directory_Table Directory_Table;
typedef struct Table_Entry Table_Entry;
int lsfs_disk_getattr(find_file, path, fsci);
int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry);
Directory_Table* lsfs_find_directory(path, drop_filename, fsci);
typedef enum Table_Entry_Kind
{
/* These are specific values since, is has to corrospond to the implementation in assembly*/
ENTRY_EMPTY = 0,
ENTRY_FILE = 1,
ENTRY_DIRECTORY = 2,
} Table_Entry_Kind;
struct Table_Entry
{
char filename[256];
unsigned long file_id[2];
unsigned long file_size[2];
void* ext_file_data_low;
void* ext_file_data_high;
long number_sector_s; /* <- Just try to remove the last undercore and compile . */
short entry_kind;
short extra_control_bits1;
short extra_control_bits2;
short extra_control_bits3;
long table_entry_sector_index[2];
long data_pointer[NUM_DATA_POINTERS * 2]; /* if it is a directory, the first pointer will be to the next table. */
};
struct lsfs_file {
unsigned long file_id[2];
long table_entry_pointer[2];
Table_Entry_Kind entry_kind;
char* filename;
long owner_id;
unsigned long size[2];
long creation_date[2];
long access_time[2];
long modification_time[2];
long number_sector;
long table_entry_sector_index[2];
long data_pointer[NUM_DATA_POINTERS * 2];
};
struct Directory_Table
{
Table_Entry entries[DEFAULT_TABLE_SIZE];
};
/*typedef struct File_System_Control_Information
{
char filesystem_information[256];
long master_table_index[2];
long this_partition_offset_on_disk[2];
long next_free_sector[2];
long next_uniqe_id[2]; /* both files and directories gets this.
long next_sector_reuse_pointer[2];
long last_sector_index_on_partition[2];
long maximum_sectors_on_disk[2];
long sector_size_on_disk[2];
long not_used[48];
} FSCI;
*/
int lsfs_disk_getattr(find_file, path, fsci)
lsfs_file* find_file;
char *path;
FSCI *fsci;
{
int i;
String_Array *split_path = string_split_c(path, '/', false);
Length_String *filename = split_path->strings[split_path->length-1];
/* Start from the master table*/
Directory_Table *dir_table = lsfs_find_directory(path, true, fsci);
for (i = 0; i < DEFAULT_TABLE_SIZE; i++)
{
int j;
print(dir_table->entries[i].filename);
print(filename->chars);
print_newline();
print_newline();
print("Size of table_entry: ");
dump_ax(sizeof(Table_Entry));
print_newline();
print_newline();
if(strcmp( filename->chars, dir_table->entries[i].filename ) == 0) {
find_file->file_id[0] = dir_table->entries[i].file_id[0];
find_file->entry_kind = dir_table->entries[i].entry_kind;
find_file->table_entry_pointer[0] = i;
find_file->filename = dir_table->entries[i].filename;
find_file->table_entry_sector_index[0] = dir_table->entries[i].table_entry_sector_index;
find_file->owner_id = 1;
find_file->size[0] = dir_table->entries[i].file_size[0]; /* dir_table->entries[i].data_pointer[0]; ;*/
find_file->creation_date[0] = 0;
find_file->access_time[0] = 0;
find_file->modification_time[0] = 0;
dump_ax(dir_table->entries[i].data_pointer[0]);
/* memcpy(find_file->data_pointer, dir_table->entries[i].data_pointer, NUM_DATA_POINTERS * 8); */
for (j = 0; j < NUM_DATA_POINTERS; j = j + 2)
{
find_file->data_pointer[j] = dir_table->entries[i].data_pointer[j];
dump_ax(find_file->data_pointer[j]);
}
find_file->number_sector = 1; /* TODO: should be loaded from disk.*/
return 1;
}
}
return 0;
}
Directory_Table* lsfs_find_directory(path, drop_filename, fsci)
char *path;
short drop_filename;
FSCI *fsci;
{
int number_of_traversal;
int i, j;
String_Array *split_path;
Directory_Table *dir_table = calloc(1, sizeof(Directory_Table));
/* printf("Table index: %lu \n",fsci->master_table_index ); */
dump_ax(fsci->master_table_index[0]);
disk_service_read_data_from_disk(fsci->master_table_index[0], (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
print(dir_table->entries[0].filename);
split_path = string_split_c(path, '/', false);
number_of_traversal = split_path->length;
if (drop_filename)
{
number_of_traversal -= 1;
}
/* Start from the master table */
for (i = 0; i < number_of_traversal; ++i)
{
for (j = 0; j < DEFAULT_TABLE_SIZE; ++j)
{
print_newline();
print("New: ");
print(dir_table->entries[j].filename);
print("vs ");
print(split_path->strings[i]->chars);
print_newline();
if (strcmp(dir_table->entries[j].filename, split_path->strings[i]->chars) == 0)
{
long index_sector = dir_table->entries[j].data_pointer[0];
/* printf("Table index: %lu \n",index_sector ); */
/* print(dir_table->entries[j].filename); */
dump_ax(index_sector);
disk_service_read_data_from_disk(index_sector, (long) DEFAULT_TABLE_SIZE, dir_table, 0x7e0);
break;
}
}
}
return dir_table;
}
int lsfs_disk_read_data_from_file(file, buffer_size, data, offset_to_next_entry, data_segment)
lsfs_file *file;
unsigned int buffer_size;
char *data;
long offset_to_next_entry;
unsigned int data_segment;
{
unsigned int integer_file_size = file->size[0];
unsigned int integer_offset = offset_to_next_entry;
unsigned int integer_datapointer = 0;
unsigned int data_length = integer_file_size - integer_offset;
unsigned int amount_read = 0;
unsigned int amount_to_read = 0;
unsigned int remaining_offset = offset_to_next_entry;
void *next_data;
/* printf("READ: buffer_size: %d\n", buffer_size); */
/* printf("READ: Data length: %d\n", data_length); */
/* printf("READ: Offset length: %d\n", offset_to_next_entry); */
int data_pointer_index = 0; /* start at first data pointer. */
if (data_length > buffer_size)
{
data_length = buffer_size;
}
while(data_length > 0) /* We have more to write */
{
/* printf("READ: Remaing Data length: %d\n", data_length); */
if (remaining_offset == 0)
{
char *tmp_buffer = calloc(DEFAULT_DATA_POINTER_SIZE, SECTOR_SIZE);
/* assert(tmp_buffer); */
if (data_length < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE))
{
amount_to_read = data_length;
}
else
{
amount_to_read = (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
}
/* disk_service_read_data_from_disk(lsfs_sector_offset index, uint32_t number_sector, void* data_buffer) */
integer_datapointer = file->data_pointer[data_pointer_index];
if (integer_datapointer == 0)
{
break;
}
print_newline();
dump_ax(file->data_pointer[data_pointer_index]);
print_newline();
next_data = data + amount_read;
dump_ax(next_data);
print_newline();
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, next_data, data_segment);
/* memcpy((data + amount_read), data_segment, tmp_buffer, 0x7e0, amount_to_read); */
data_length -= amount_to_read;
amount_read += amount_to_read;
data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
/* free(tmp_buffer); */
}
else if (remaining_offset < (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE))
{
char *tmp_buffer = calloc(1, (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE));
/* assert(tmp_buffer); */
if (data_length < ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset) )
{
amount_to_read = data_length;
}
else
{
amount_to_read = ((DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE) - remaining_offset);
}
disk_service_read_data_from_disk(file->data_pointer[data_pointer_index], (long) DEFAULT_DATA_POINTER_SIZE, tmp_buffer, 0x7e0);
memcpy(data, data_segment, (tmp_buffer + remaining_offset), 0x7e0, amount_to_read);
data_length -= amount_to_read;
amount_read += amount_to_read;
remaining_offset -= amount_to_read;
data_pointer_index = data_pointer_index + 2; /* Rember that we only use 32-bit, and thats why we jump to at a time*/
/* free(tmp_buffer); */
}
else
{
/* We have to skip a whole data pointer: */
remaining_offset -= (DEFAULT_DATA_POINTER_SIZE * SECTOR_SIZE);
data_pointer_index = data_pointer_index + 2;
}
}
/*
time_t current_time;
time ( &current_time );
file->access_time = current_time;
*/
return amount_read;
}
#endif
implementation/lsfs.s
+1059 -436
View File
File diff suppressed because it is too large. Load diff
lsfs.s
+2469
View File
File diff suppressed because it is too large. Load diff
main.c
+36 -12
View File
@@ -4,6 +4,7 @@
/* */
#include "main.h"
int main(selector, pointer_parameter_segment, pointer_parameter_struct)
int selector;
void* pointer_parameter_segment;
@@ -12,19 +13,19 @@ void* pointer_parameter_struct;
/* selectot should be a "selector" for which disk service*/
/* one wnats to use. */
/* 0 should not be used, to try to ensure that a value has been set explicitly. */
FSCI fsci;
Service_Action service_action;
Directory_Table current_table;
Parameter_Struct parameter_struct;
int local_segment = 0x7e0;
unsigned int heap_start = 0x2000;
unsigned int heap_start = 0x2200;
unsigned int heap_end = 0xffff;
int stack_segment = 0x8fc0;
int path_length;
long index_as_long;
long index_as_long = 0;
char *local_path = 0;
FSCI *fsci = 0x2000;
service_action = selector;
switch (service_action)
@@ -35,20 +36,36 @@ void* pointer_parameter_struct;
What do we need to know:
Index of FSCI
*/
set_heap_settings(heap_start, heap_end);
index_as_long = pointer_parameter_struct;
disk_service_read_data_from_disk(index_as_long, 1, &fsci, stack_segment);
disk_service_read_data_from_disk(index_as_long, (long) 1, fsci, local_segment);
print("File System has been loaded: ");
print_newline();
set_heap_settings(heap_start, heap_end);
print_stack(fsci.filesystem_information);
print(fsci->filesystem_information);
print_newline();
dump_ax(fsci->master_table_index[0]);
print_newline();
} break;
case SERVICE_FIND_ENTRY:
{
String_Array *path_array;
lsfs_file* find_file;
int i;
dump_ax(fsci->master_table_index[0]);
disk_service_read_data_from_disk(fsci->master_table_index[0], (long) DEFAULT_TABLE_SIZE, &current_table, stack_segment);
print("Current table: ");
print_newline();
print_stack(current_table.entries[0].filename);
print_newline();
print_stack(current_table.entries[1].filename);
print_newline();
print_stack(current_table.entries[2].filename);
print_newline();
memcpy(&parameter_struct, stack_segment, pointer_parameter_struct, pointer_parameter_segment, sizeof(Parameter_Struct));
path_length = strlen(parameter_struct.path, pointer_parameter_segment);
dump_ax(path_length);
local_path = malloc(256);
memcpy(local_path, local_segment, parameter_struct.path, pointer_parameter_segment, path_length);
local_path[path_length] = 0;
@@ -66,16 +83,23 @@ void* pointer_parameter_struct;
print_newline();
print_newline();
find_file = calloc(sizeof(lsfs_file), 1);
lsfs_disk_getattr(find_file, local_path, fsci);
print_newline();
disk_service_read_data_from_disk(fsci.master_table_index[0], DEFAULT_TABLE_SIZE, &current_table, stack_segment);
print("Current table: ");
print("Loding SingOS kernel: ");
print(find_file->filename);
print_newline();
print_stack(current_table.entries[0].filename);
print("Kernel file id: ");
dump_ax(find_file->file_id[0]);
print_newline();
print_stack(current_table.entries[1].filename);
print_newline();
print_stack(current_table.entries[2].filename);
print("Kernel file size: ");
dump_ax(find_file->size[0]);
print_newline();
print("Kernel first data pointer: ");
dump_ax(find_file->data_pointer[0]);
lsfs_disk_read_data_from_file(find_file, 0xffff, 0x00, (long) 0x0, 0x50);
} break;
case SERIVCE_READ_DATA:
main.h
+7 -34
View File
@@ -1,14 +1,17 @@
#ifndef MAIN_H
#define MAIN_H
#define false 0
#define true 1
#define SPACE_MBR_RECORD 2048 /* Sectors*/
#define SPACE_VBR_RECORD 2048 /* Sectors*/
#define SIZE_FSCI_RECORD 1 /* Sectors*/
#define DEFAULT_ENTRY_SIZE 1 /* Sectors*/
#define SECTOR_SIZE 512 /* BYTES*/
#define NUMBER_OF_MBR_PARTITIONS 4
#define DEFAULT_FILE_SIZE 4 /* This is in sectors*/
#define DEFAULT_DATA_POINTER_SIZE 4 /* This is in sectors*/
#define DEFAULT_FILE_SIZE 8 /* This is in sectors*/
#define DEFAULT_DATA_POINTER_SIZE 8 /* This is in sectors*/
#define DEFAULT_TABLE_SIZE 16
#define NUM_DATA_POINTERS 27
@@ -17,27 +20,17 @@
#include "std_singos/string.h"
#include "driver/disk.h"
#include "implementation/lsfs.h"
void dump_ax(input);
void print_stack(argument);
void print_newline();
typedef struct Directory_Table Directory_Table;
typedef struct Struct_Table_Entry Table_Entry;
typedef struct struct_partition_control partition_control;
typedef struct File_System_Control_Information FSCI;
typedef struct meta_information_format mif;
typedef struct tag_record tag_record;
typedef struct Parameter_Struct Parameter_Struct;
typedef enum Table_Entry_Kind
{
/* These are specific values since, is has to corrospond to the implementation in assembly*/
ENTRY_EMPTY = 0,
ENTRY_FILE = 1,
ENTRY_DIRECTORY = 2,
} Table_Entry_Kind;
typedef enum Service_Action
{
@@ -48,22 +41,6 @@ typedef enum Service_Action
} Service_Action;
struct Struct_Table_Entry
{
char filename[256];
long file_id[2];
long file_size[2];
void* ext_file_data_low;
void* ext_file_data_high;
long number_sector_s; /* <- Just try to remove the last undercore and compile . */
short entry_kind;
short extra_control_bits1;
short extra_control_bits2;
short extra_control_bits3;
long table_entry_sector_index[2];
long data_pointer[NUM_DATA_POINTERS * 2]; /* if it is a directory, the first pointer will be to the next table. */
};
struct File_System_Control_Information
{
char filesystem_information[256];
@@ -79,11 +56,6 @@ struct File_System_Control_Information
};
typedef struct Directory_Table
{
Table_Entry entries[DEFAULT_TABLE_SIZE];
};
struct Parameter_Struct
{
@@ -94,7 +66,8 @@ struct Parameter_Struct
int buffer_size;
int data_length;
int byte_offset_into_file;
Table_Entry_Kind entry_kind;
short entry_kind;
};
#include "implementation/lsfs.h"
#endif
main.s
+2067 -537
View File
File diff suppressed because it is too large. Load diff
std_singos/string.h
+58
View File
@@ -165,6 +165,64 @@ int num_bytes;
#endasm
}
int strcmp(source_1, source_2)
char* source_1;
char* source_2;
{
int i;
int count;
count = strlen(source_1, 0x7e0);
if (count != strlen(source_2, 0x7e0))
{
return -1;
}
for (i = 0; i < count; i++)
{
if(source_1[i] != source_2[i])
{
return -1;
}
}
return 0;
/*
#asm
#define DESTINATION 4[bp];
#define DESTINATION_SEGMENT 6[bp];
#define SOURCE 8[bp];
#define SOURCE_SEGMENT 10[bp];
; Compares two strings
; IN si: the first (zero terminated) string
; IN di: the second (zero terminated) string
; OUT SF and ZF (same semantics as cmp)
strcmp_stringcompare:
push bx
push si
push di
.strcmp_loop:
mov bl, [si]
mov bh, [di]
cmp bl, bh
jne .strcmp_end
test bl, bl ; bl and bh are the same, so bl = 0 => dl = 0
jz .strcmp_end
inc si
inc di
jmp .strcmp_loop
.strcmp_end:
pop di
pop si
pop bx
ret
#endasm
*/
}
String_Array *string_split_c(string, delim, keep_delim)
char *string;
char delim;