Fixed memory corruption

src/kernel/kmain.c

@@ -34,23 +34,6 @@ void sysinit(){
     else{
         mlog("KERNEL", "ERROR: Initrc could not be located!\n", MLOG_PRINT);
     }
-    
-    vfile_t *disk_dir = fopen("/dev/disk");
-    if(disk_dir == 0){
-        mlog("KERNEL", "Error: /dev/disk does not exist\n", MLOG_PRINT);
-    }
-    char *dir_data = kmalloc(1);
-    uint32_t byte_count = fread(disk_dir, dir_data, 0, 4096);
-    uint32_t file_count = byte_count/sizeof(vfile_t);
-    for(uint32_t i = 0; i < byte_count; i++){
-        if(dir_data[i] > 32 && dir_data[i] < 127){
-            printf("%c", dir_data[i]);
-        }
-        else{
-            printf("%d", dir_data[i]);
-        }
-    //     vfs_detect_partitions(dir_data[i]);
-    }
     // dispatch_message(0);
     printf("Bleh\n");
     //why did i stop working on this? what was wrong with this?

src/kernel/shared/string.h

@@ -21,6 +21,21 @@ inline uint32_t strcmp(char *str1, char *str2){
     if(str1[i] == str2[i]) return 0;
     else return 1;
 }
+
+inline void memclr(char *ptr, uint32_t count){
+    if(count % 4 == 0){
+        uint32_t *intptr = (uint32_t *)ptr;
+        for(uint32_t i = 0; i < count/4; i++){
+            intptr[i] = 0;
+        }
+        return;
+    }
+    for(uint32_t i = 0; i < count; i++){
+        ptr[i] = 0;
+    }
+    return;
+}
+
 char *strtok(char *str, char delim);
 void strcpy(char *src, char *dest);
 void memcpy(char *src, char *dest, uint32_t c);

src/kernel/system/elf.c

@@ -1,5 +1,6 @@
 #include "elf.h"
 #include "../shared/kstdlib.h"
+#include "../shared/string.h"
 #include "../shared/memory.h"
 
 #define MODULE_NAME "ELFLOAD"
@@ -14,21 +15,9 @@ void *load_segment(program_entry_t entry, void *file_data, void *base_segment, u
     // printf("Base: %x\n", base_segment);
     if(entry.type == 1){
         if(((elf_header_t *)(file_data))->type == ELF_TYPE_SHARED){
-            //Overwrites data when sees free memory block; re-write to allocate before call
-            if(base_segment == 0){
-                segment = kmalloc(entry.msize/4096 + 1);
-                base_segment = segment;
-            }
-            else{
             segment = base_segment + (entry.vaddr & 0xfffff000);
-                uint32_t count = 1;
-                count += ((entry.vaddr+entry.msize) - entry.vaddr) ? 1 : 0;
-                count += entry.msize/4096 + 1;
-                printf("%x\n", segment);
-                for(uint32_t i = 0; i < count; i++){
-                    map(segment + (i << 12)/4, (void *)pm_alloc(), PT_PRESENT | map_flags);
-                }
-            }
+            memclr(segment, entry.msize);
+            
             for(uint32_t i = 0; i < entry.fsize/sizeof(uint32_t) + 1; i++){
                 segment[i] = ((uint32_t *)(file_data))[i + entry.data_offset/sizeof(uint32_t)];
             }
@@ -42,6 +31,7 @@ void *load_segment(program_entry_t entry, void *file_data, void *base_segment, u
         //What is this for?
         //TODO: Find out how to handle Dynamic sections
     }
+    
     // printf("data_offset: %x\n", data_offset);
     return base_segment;
 }
@@ -55,7 +45,12 @@ void *load_elf(void *file_data, uint32_t map_flags){
     program_entry_t *program_header = file_data + header->program_header_offset;
     uint32_t program_header_count = header->program_entry_count;
     mlog(MODULE_NAME, "PROGRAM ENTRIES: %d\n", MLOG_PRINT, program_header_count);
-    void *base_segment = 0;
+    uint32_t size_pages = 0;
+    for(uint32_t i = 0; i < program_header_count; i++){
+        size_pages += (program_header[i].msize + PAGE_SIZE_BYTES - 1) / PAGE_SIZE_BYTES;
+    }
+    // printf("Requires %d pages\n", size_pages)
+    void *base_segment = kmalloc(size_pages);
     for(uint32_t i = 0; i < program_header_count; i++){
         base_segment = load_segment(program_header[i], file_data, base_segment, map_flags);
     }

src/kernel/system/ramfs.c

@@ -22,18 +22,15 @@ void ramfs_init(){
     mlog(MODULE_NAME, "Initializing VFS\n", MLOG_PRINT);
     root_dir.private = 0;
     root_dir.size = 0;
-    // printf("Sizeof VFILE_T: %d", sizeof(vfile_t));
 }
 
 vfile_t *search_dir(char *subname, vfile_t *directory){
-    printf("Searching for: %s\n", subname);
     if(!directory) return 0;
     vfile_t **children = (vfile_t **)directory->private;
     if(!children){
         return 0;
     }
     for(int i = 0; i < directory->size / sizeof(vfile_t *); i++){
-        printf("Child name: %s\n", children[i]->name);
         if(children[i] && !strcmp(children[i]->name, subname)){
             return children[i];
         }
@@ -120,7 +117,6 @@ int ramfs_resize(vfile_t *file, uint32_t new_size_bytes){
         file->private = new_ptr;
     }while(0);
     file->size = new_size_bytes;
-    // printf("New file size for file: %s, %d\n", file->name, file->size);
     return new_size_bytes;
 }
 
@@ -137,7 +133,6 @@ vfile_t *ramfs_create(vfile_t *root, char *path, FS_FILE_FLAGS flags){
         return 0;
     }
     char *new_name = path;
-    // printf("%d\n", parent->size);
     vfile_t **dirents = (vfile_t **)parent->private;
     uint32_t insert_index = 0;
     for(uint32_t i = 0; i < parent->size/sizeof(vfile_t *); i++){
@@ -166,18 +161,15 @@ vfile_t *ramfs_create(vfile_t *root, char *path, FS_FILE_FLAGS flags){
     dirents[parent->size/(sizeof(vfile_t*)) - 1] = new_file;
     new_file->fileops = &ramfs_ops;
     path--;
-    // printf("Returning file with name: %s\n", new_file->name);
     return new_file;
 }
 
 int ramfs_translate_dir(vfile_t *file, void *buffer, uint32_t offset, uint32_t count){
     uint32_t dirents_requested = count / sizeof(vfile_t);
     uint32_t dirents_availible = file->size / sizeof(vfile_t *);
-    printf("Sizeof vfile_t %d with %d entries fitting in buffer, and %d entries in file %s\n", sizeof(vfile_t), dirents_requested, dirents_availible, file->name);
     uint32_t to_copy = unsigned_min(dirents_availible, dirents_requested);
     vfile_t **dirents = (vfile_t **)file->private;
     for(uint32_t i = 0; i < to_copy; i++){
-        // printf("From: %x to %x\n", dirents[i], buffer + i * sizeof(vfile_t));
         memcpy(dirents[i], buffer + i * sizeof(vfile_t), sizeof(vfile_t));
     }
     return to_copy * sizeof(vfile_t);

src/kernel/system/vfs.c

@@ -23,13 +23,11 @@ vfile_t *fcreate(char *path, FS_FILE_FLAGS flags){
     // return 0;
     spinlock_acquire(vfs_lock);
     vfile_t *returnable = vfcreate(get_root_dir(), path, flags);
-    printf("Making file: %s, %x\n", path, returnable);
     spinlock_release(vfs_lock);
     return returnable;
 }
 
 vfile_t *vfcreate(vfile_t *parent_dir, char *relpath, FS_FILE_FLAGS flags){
-    // printf("%s\n", relpath);
     if(!relpath){
         return 0;
     }
@@ -49,10 +47,8 @@ vfile_t *vfcreate(vfile_t *parent_dir, char *relpath, FS_FILE_FLAGS flags){
         name_index++;
     }
     name[name_index] = 0;
-    // printf("%d, %s,", subpath_start, name + subpath_start);
     
     if(name_index >= name_length){//if there is no other directory
-        // printf("Creating file; name: %s\n", name);
         new_file = parent_dir->fileops->create(parent_dir, name, flags);
     }
     else{
@@ -62,12 +58,10 @@ vfile_t *vfcreate(vfile_t *parent_dir, char *relpath, FS_FILE_FLAGS flags){
             kfree(name);
             return 0;
         }
-        // printf("%s", new_parent->name);
         new_file = vfcreate(new_parent, name+name_index+1, flags);
         // fclose(new_parent);
     }
     kfree(name);
-    // printf("Returning new file!\n");
     return new_file;
     // return 0;
 }
@@ -116,7 +110,6 @@ vfile_t *fopen(char *name){
     if(!strcmp(name, "/")){
         return root;
     }
-    printf("Opening file: %s\n", name + (name[0] == '/'));
     return root->fileops->rfopen(name + (name[0] == '/'), root);
 }
 

src/kmodules/disk_driver.c

@@ -8,6 +8,17 @@
 
 KOS_MAPI_FP api;
 
+int ata_read(vfile_t *file, uint8_t *ptr, uint32_t offset, uint32_t count);
+int ata_write(vfile_t *file, void *ptr, uint32_t offset, uint32_t count);
+fileops_t ide_fileops = {
+    0,
+    0,
+    ata_write,
+    ata_read,
+    0,
+    0,
+};
+
 /*
 TODO:
 Register module 
@@ -534,7 +545,8 @@ uint8_t ata_identify(uint32_t index, uint16_t disk){
     //
     // new_file->read = ata_read;
     // new_file->write = ata_write;
-    // new_file->id = index;
+    new_file->id = index;
+    new_file->fileops = &ide_fileops;
     puts(api, "KIDM", "Valid Drive!\n");
     return 0;
 }