From 2f2a7a3e451fbe0d41d3835dded684f2567340d5 Mon Sep 17 00:00:00 2001 From: Xnoe Date: Wed, 19 Jan 2022 16:51:37 +0000 Subject: [PATCH] Added file reading via filehandlers. Added support for directories. Processes are now created using filehandlers. --- Makefile | 6 +- src/common/common.c | 12 +- src/common/common.h | 5 +- src/kernel/atapio.cpp | 162 ++++++++++++++++++++++---- src/kernel/atapio.h | 57 +++++++++ src/kernel/datatypes/hashtable.h | 2 +- src/kernel/global.cpp | 1 + src/kernel/global.h | 6 + src/kernel/idt.cpp | 25 +++- src/kernel/kernel.cpp | 18 +-- src/kernel/kernel.h | 6 +- src/kernel/kmain.cpp | 5 +- src/kernel/process.cpp | 70 ++++++----- src/kernel/process.h | 2 +- src/kernel/stdio/circularrwbuffer.cpp | 8 +- src/kernel/stdio/circularrwbuffer.h | 5 +- src/kernel/stdio/readwriter.cpp | 5 +- src/kernel/stdio/readwriter.h | 5 +- src/kernel/terminal.cpp | 4 +- src/kernel/terminal.h | 4 +- src/world/world.c | 11 +- 21 files changed, 323 insertions(+), 96 deletions(-) diff --git a/Makefile b/Makefile index 131e10d..86b6492 100644 --- a/Makefile +++ b/Makefile @@ -2,7 +2,7 @@ CFLAGS = -g -std=gnu11 -m32 -mgeneral-regs-only -nostdlib -fno-builtin -fno-exce CXXFLAGS = -g -m32 -fno-use-cxa-atexit -mgeneral-regs-only -nostdlib -fno-builtin -fno-rtti -fno-exceptions -fno-leading-underscore -fpermissive -fno-pie -fno-stack-protector -I. LDFLAGS = -DISK_IMG_FILES = build/kernel/kernel.bin build/world/world.bin hello.txt alpha.txt \ +DISK_IMG_FILES = build/kernel/kernel.bin hello.txt alpha.txt \ build/hello/hello.bin KERNEL_CPP_SRCS = $(wildcard src/kernel/*.cpp) $(wildcard src/kernel/*/*.cpp) @@ -39,12 +39,14 @@ run: disk.img debug: disk.img qemu-system-i386 -s -S -no-reboot -no-shutdown disk.img & gdb --command=gdbscript -disk.img: clean prepare build/boot/boot.bin build/boot_stage2/boot.bin $(DISK_IMG_FILES) +disk.img: clean prepare build/boot/boot.bin build/boot_stage2/boot.bin $(DISK_IMG_FILES) build/world/world.bin dd if=/dev/zero of=disk.img count=43 bs=100k dd if=build/boot/boot.bin of=disk.img conv=notrunc dd obs=512 seek=1 if=build/boot_stage2/boot.bin of=disk.img conv=notrunc mount disk.img img.d + mkdir img.d/etc/ cp $(DISK_IMG_FILES) img.d/ + cp build/world/world.bin img.d/etc/world.bin sleep 0.1 umount img.d chmod 777 disk.img diff --git a/src/common/common.c b/src/common/common.c index fae785c..697788d 100644 --- a/src/common/common.c +++ b/src/common/common.c @@ -28,8 +28,8 @@ int write(uint32_t count, void* filehanlder, uint8_t* buffer) { asm volatile ("mov $11, %%eax; mov %0, %%ebx; mov %1, %%esi; mov %2, %%edi; int $0x7f" : : "m" (count), "m" (filehanlder), "m" (buffer): "ebx", "esi", "edi"); } -uint32_t fork(char* filename) { - asm volatile("mov $7, %%eax; mov %0, %%esi; int $0x7f" : : "m" (filename) : "esi"); +uint32_t fork(uint32_t fh) { + asm volatile("mov $7, %%eax; mov %0, %%esi; int $0x7f" : : "m" (fh) : "esi"); } uint32_t bindStdout(uint32_t PID) { @@ -40,6 +40,14 @@ uint32_t bindStdin(uint32_t PID) { asm volatile("mov $14, %%eax; mov %0, %%esi; int $0x7f" : : "m" (PID) : "esi"); } +int fopen(char* filename) { + asm volatile("mov $15, %%eax; mov %0, %%esi; int $0x7f" : : "m" (filename) : "esi"); +} + +void fclose(uint32_t fh) { + asm volatile("mov $16, %%eax; mov %0, %%esi; int $0x7f" : : "m" (fh) : "esi"); +} + void bindToKeyboard() { asm volatile ("mov $12, %%eax; int $0x7f" : : :); } diff --git a/src/common/common.h b/src/common/common.h index bf52277..b9f8dac 100644 --- a/src/common/common.h +++ b/src/common/common.h @@ -9,7 +9,7 @@ void* localalloc(uint32_t size); void localdelete(void* ptr); uint32_t filesize(char* filename); -uint32_t fork(char* filename); +uint32_t fork(uint32_t fh); uint32_t bindStdout(uint32_t PID); uint32_t bindStdin(uint32_t PID); @@ -19,6 +19,9 @@ int read(uint32_t count, void* filehandler, uint8_t* buffer); int write(uint32_t count, void* filehandler, uint8_t* buffer); void bindToKeyboard(); +int fopen(char* filename); +void fclose(uint32_t fh); + int int_to_decimal(unsigned int number, char* string_buffer); int int_to_hex(unsigned int number, char* string_buffer); diff --git a/src/kernel/atapio.cpp b/src/kernel/atapio.cpp index e38b4c9..b906969 100644 --- a/src/kernel/atapio.cpp +++ b/src/kernel/atapio.cpp @@ -11,7 +11,7 @@ uint16_t identify_result[256]; uint32_t total_28_lbas = 0; -uint8_t* rootDirEntries; +DirectoryEntry* rootDirEntries; uint16_t* FAT1; uint16_t countReserved; @@ -21,7 +21,7 @@ uint16_t sectorsPerFAT; void init_atapio() { - rootDirEntries = new uint8_t[8192]; + rootDirEntries = (DirectoryEntry*)new uint8_t[8192]; FAT1 = (uint16_t*)(new uint8_t[512 * 34]); uint32_t boot_sector = new uint32_t[1024]; @@ -65,7 +65,7 @@ void init_atapio() { total_28_lbas = *(uint32_t*)(identify_result+60); // We've initialised now, let's load the FAT and RootDirEntries. - read_sectors(sectorsPerFAT * countFATs + countReserved, countRDEs / 16, rootDirEntries); + read_sectors(sectorsPerFAT * countFATs + countReserved, countRDEs / 16, (uint8_t*)rootDirEntries); read_sectors(countReserved, sectorsPerFAT, (uint8_t*)FAT1); } @@ -97,27 +97,46 @@ void read_sectors(uint32_t address, int count, uint8_t* buffer) { } } -uint16_t file_exists(char* filename) { - for (int i=0; ifirstClusterLow); + dirbuf = (DirectoryEntry*)(new uint8_t[size]); + uint32_t cluster = de->firstClusterLow; + load_file(cluster, (uint8_t*)dirbuf); + dir.entry = dirbuf; + dir.entries = size / 32; + break; + } + } + } + + char normalname[11]; + to83(levels[count-1], normalname); + + for (int i=0; ifirstClusterLow; + return 0; +} + +uint32_t file_size(char* filename) { + for (int i=0; ifirstClusterLow, location); +} + +FATFileReadWriter::FATFileReadWriter(uint32_t owner, char* filename) +: ReadWriter(owner) { + this->bytesRead = 0; + DirectoryEntry* de = get_DE(filename); + this->sizeBytes = de->size; + this->currentCluster = de->firstClusterLow; + this->read_buffer = new uint8_t[512]; + read_sector(clusterToSector(this->currentCluster), this->read_buffer); +} + +uint32_t FATFileReadWriter::read(uint32_t count, uint8_t* buffer) { + int index = 0; + while (count) { + buffer[index] = this->read_buffer[this->bytesRead++]; + if (this->bytesRead == 512) { + this->currentCluster = FAT1[this->currentCluster++]; + read_sector(clusterToSector(this->currentCluster), this->read_buffer); + this->bytesRead = 0; + } + count--; + index++; + } +} +uint32_t FATFileReadWriter::write(uint32_t count, uint8_t* buffer) {} +uint32_t FATFileReadWriter::size() { + return this->sizeBytes; +} diff --git a/src/kernel/atapio.h b/src/kernel/atapio.h index 6f5b618..52f509f 100644 --- a/src/kernel/atapio.h +++ b/src/kernel/atapio.h @@ -9,6 +9,49 @@ #include "allocate.h" #include "global.h" +#include "stdio/readwriter.h" + +struct __attribute__((packed)) DirectoryEntry { + char name[11]; + uint8_t _ignored0 : 3; + uint8_t archive : 1; + uint8_t directory : 1; + uint8_t volumeid : 1; + uint8_t system : 1; + uint8_t hidden : 1; + uint8_t readonly : 1; + uint8_t _ignored1; + uint16_t createdHour : 5; + uint16_t createdMinute : 6; + uint16_t createdSecond : 5; + + uint16_t createdYear : 7; + uint16_t createdMonth : 4; + uint16_t createdDay : 5; + + uint16_t lastAccessYear : 7; + uint16_t lastAccessMonth : 4; + uint16_t lastAccessDay : 5; + + uint16_t firstClusterHigh; + + uint16_t modifiedHour : 5; + uint16_t modifiedMinute : 6; + uint16_t modifiedSecond : 5; + + uint16_t modifiedYear : 7; + uint16_t modifiedMonth : 4; + uint16_t modifiedDay : 5; + + uint16_t firstClusterLow; + uint32_t size; +}; + +struct Directory { + DirectoryEntry* entry; + uint32_t entries; +}; + void init_atapio(); void read_sector(uint32_t address, uint8_t* buffer); void read_sectors(uint32_t address, int count, uint8_t* buffer); @@ -17,4 +60,18 @@ void load_file(char* filename, uint8_t* location); uint32_t file_size(char* filename); +class FATFileReadWriter : public ReadWriter { +private: + uint32_t sizeBytes; + uint32_t bytesRead; + uint32_t currentCluster; + uint8_t* read_buffer; + +public: + FATFileReadWriter(uint32_t owner, char* filename); + uint32_t read(uint32_t count, uint8_t* buffer) override; + uint32_t write(uint32_t count, uint8_t* buffer) override; + uint32_t size() override; +}; + #endif \ No newline at end of file diff --git a/src/kernel/datatypes/hashtable.h b/src/kernel/datatypes/hashtable.h index c6438a8..12add28 100644 --- a/src/kernel/datatypes/hashtable.h +++ b/src/kernel/datatypes/hashtable.h @@ -55,7 +55,7 @@ namespace xnoe { return xnoe::Maybe(); } - void remove(key k, value v) { + void remove(key k) { xnoe::linkedlist>* list = &table[xnoe::hash(k) % 4096]; xnoe::linkedlistelem>* current = list->start; if (current) { diff --git a/src/kernel/global.cpp b/src/kernel/global.cpp index 63689a0..f1b6856 100644 --- a/src/kernel/global.cpp +++ b/src/kernel/global.cpp @@ -6,6 +6,7 @@ namespace Global { Process* currentProc = 0; tss_struct* tss = 0; bool currentProcValid = false; + xnoe::hashtable* FH; // Map of File Handlers -> Read Writer } void* operator new (uint32_t size) { diff --git a/src/kernel/global.h b/src/kernel/global.h index a35a93a..10c3a8b 100644 --- a/src/kernel/global.h +++ b/src/kernel/global.h @@ -7,6 +7,11 @@ class Kernel; class Allocator; class Process; struct tss_struct; +class ReadWriter; +namespace xnoe { + template + class hashtable; +} namespace Global { extern Allocator* allocator; @@ -14,6 +19,7 @@ namespace Global { extern Process* currentProc; extern tss_struct* tss; extern bool currentProcValid; + extern xnoe::hashtable* FH; } void* operator new (uint32_t size); diff --git a/src/kernel/idt.cpp b/src/kernel/idt.cpp index d7c8251..1fcc6d0 100644 --- a/src/kernel/idt.cpp +++ b/src/kernel/idt.cpp @@ -164,6 +164,9 @@ void syscall(frame_struct* frame) { // 13: bindStdout :: int PID esi -> int filehandler // Returns a filehandler for a CircularRWBuffer binding stdout of another process. // 14: bindStdin :: int PID esi -> int filehandler // Returns a filehandler for a CircularRWBuffer binding stdin of another process. + // 15: fopen :: char* path esi -> int filehandler // Returns a filehandler to the file. + // 16: fclose :: int filehandler esi -> void // Closes a file handler. + // File handlers: // 0: Stdout // 1: Stdin @@ -196,10 +199,7 @@ void syscall(frame_struct* frame) { break; case 7: { asm("cli"); - char filename[12]; - for (int i=0; i<12; i++) - filename[i] = ((char*)(frame->esi))[i]; - Process* p = Global::kernel->createProcess(filename); + Process* p = Global::kernel->createProcess(esi); rval = p->PID; asm("sti"); break; @@ -219,7 +219,7 @@ void syscall(frame_struct* frame) { rval = stdin->read(frame->ebx, edi); } else { - xnoe::Maybe fh = Global::kernel->FH->get(esi); + xnoe::Maybe fh = Global::FH->get(esi); if (!fh.is_ok()) { rval = 0; break; @@ -239,7 +239,7 @@ void syscall(frame_struct* frame) { rval = stdout->write(frame->ebx, edi); } else { - xnoe::Maybe fh = Global::kernel->FH->get(esi); + xnoe::Maybe fh = Global::FH->get(esi); if (!fh.is_ok()) { rval = 0; break; @@ -285,6 +285,19 @@ void syscall(frame_struct* frame) { break; } + case 15: { + ReadWriter* file = new FATFileReadWriter(0, esi); + rval = Global::kernel->mapFH(file); + } + + case 16: { + xnoe::Maybe f = Global::FH->get(esi); + if (f.is_ok()) { + delete f.get(); + Global::kernel->unmapFH(esi); + } + } + default: break; } diff --git a/src/kernel/kernel.cpp b/src/kernel/kernel.cpp index 40d4f14..3a6736a 100644 --- a/src/kernel/kernel.cpp +++ b/src/kernel/kernel.cpp @@ -18,12 +18,12 @@ Kernel::Kernel(PageDirectory* page_directory, PageMap* phys, PageMap* virt, uint void Kernel::init_kernel() { this->pid_map = new xnoe::hashtable(); - this->FH = new xnoe::hashtable(); + Global::FH = new xnoe::hashtable(); this->globalISRStack = (new uint8_t[0x8000]) + 0x8000; } -Process* Kernel::createProcess(char* filename) { - Process* p = new Process(currentPID, this->PD, 0xc0000000, filename); +Process* Kernel::createProcess(uint32_t fh) { + Process* p = new Process(currentPID, this->PD, 0xc0000000, fh); this->pid_map->set(currentPID, p); currentPID++; @@ -32,23 +32,27 @@ Process* Kernel::createProcess(char* filename) { return p; } -Process* Kernel::createProcess(char* filename, ReadWriter* stdout) { - Process* p = this->createProcess(filename); +Process* Kernel::createProcess(uint32_t fh, ReadWriter* stdout) { + Process* p = this->createProcess(fh); p->stdout = stdout; return p; } void Kernel::destroyProcess(Process* p) { this->processes.remove(p); - this->pid_map->remove(p->PID, p); + this->pid_map->remove(p->PID); delete p; } int Kernel::mapFH(ReadWriter* fh) { - this->FH->set(this->lastFH++, fh); + Global::FH->set(this->lastFH++, fh); return this->lastFH - 1; } +void Kernel::unmapFH(uint32_t fh) { + Global::FH->remove((void*)fh); +} + //void Kernel::loadPrimaryStack() { // asm volatile("mov %0, %%esp"::"m"(this->stack - 64)); //} \ No newline at end of file diff --git a/src/kernel/kernel.h b/src/kernel/kernel.h index 4687575..12af0af 100644 --- a/src/kernel/kernel.h +++ b/src/kernel/kernel.h @@ -16,7 +16,6 @@ public: Terminal* terminal; xnoe::hashtable* pid_map; // Map of PIDs -> Process*s - xnoe::hashtable* FH; // Map of File Handlers -> Read Writer xnoe::linkedlist processes; xnoe::linkedlist KBListeners; @@ -25,11 +24,12 @@ public: void init_kernel(); - Process* createProcess(char* filename); - Process* createProcess(char* filename, ReadWriter* stdout); + Process* createProcess(uint32_t fh); + Process* createProcess(uint32_t fh, ReadWriter* stdout); void destroyProcess(Process* p); int mapFH(ReadWriter* fh); + void unmapFH(uint32_t fh); //void loadPrimaryStack(); }; diff --git a/src/kernel/kmain.cpp b/src/kernel/kmain.cpp index 3d9ce72..5375daf 100644 --- a/src/kernel/kmain.cpp +++ b/src/kernel/kmain.cpp @@ -44,7 +44,10 @@ int main() { term->printf("KERNEL OK!\n"); - Process* p1 = kernel.createProcess("WORLD BIN", term); + ReadWriter* worldbin = new FATFileReadWriter(0, "etc/world.bin"); + uint32_t fh = kernel.mapFH(worldbin); + + Process* p1 = kernel.createProcess(fh, term); init_keyboard(); diff --git a/src/kernel/process.cpp b/src/kernel/process.cpp index 10d6b6d..4a24aa2 100644 --- a/src/kernel/process.cpp +++ b/src/kernel/process.cpp @@ -33,7 +33,7 @@ Process::Process(uint32_t PID) this->kernelStackPtr = (new uint8_t[0x1000]) + 0x1000; } -Process::Process(uint32_t PID, PageDirectory* inherit, uint32_t inheritBase, char* filename) +Process::Process(uint32_t PID, PageDirectory* inherit, uint32_t inheritBase, uint32_t fh) : Allocator(new PageDirectory, new PageMap, (uint32_t)0, 3) { this->stdout = 0; this->stdin = 0; @@ -47,45 +47,51 @@ Process::Process(uint32_t PID, PageDirectory* inherit, uint32_t inheritBase, cha for (int index = inheritBase >> 22; index < 1024; index++) this->PD->page_directory[index] = inherit->page_directory[index]; - uint8_t* program_data = this->allocate(file_size(filename) + 12) + 12; + xnoe::Maybe file = Global::FH->get(fh); + if (file.is_ok()) { + ReadWriter* filereader = file.get(); + uint32_t filesize = filereader->size(); + uint8_t* program_data = this->allocate(filesize + 12) + 12; - this->stack = this->allocate(0x8000); - this->kernelStackPtr = (new uint8_t[0x1000]) + 0xffc; - this->kernelStackPtrDefault = this->kernelStackPtr; + this->stack = this->allocate(0x8000); + this->kernelStackPtr = (new uint8_t[0x1000]) + 0xffc; + this->kernelStackPtrDefault = this->kernelStackPtr; - uint32_t pCR3; - asm ("mov %%cr3, %0" : "=a" (pCR3) :); - this->PD->select(); + uint32_t pCR3; + asm ("mov %%cr3, %0" : "=a" (pCR3) :); + this->PD->select(); - // We also need to initialise ESP and the stack - uint32_t* stack32 = ((uint32_t)this->kernelStackPtr); - *(--stack32) = 0x23; // SS - *(--stack32) = ((uint32_t)this->stack + 0x8000); // ESP - *(--stack32) = 0x200; // EFLAGS - *(--stack32) = 27; // CS - *(--stack32) = (uint32_t)program_data; // EIP - *(--stack32) = ((uint32_t)this->stack + 0x8000); // EBP + // We also need to initialise ESP and the stack + uint32_t* stack32 = ((uint32_t)this->kernelStackPtr); + *(--stack32) = 0x23; // SS + *(--stack32) = ((uint32_t)this->stack + 0x8000); // ESP + *(--stack32) = 0x200; // EFLAGS + *(--stack32) = 27; // CS + *(--stack32) = (uint32_t)program_data; // EIP + *(--stack32) = ((uint32_t)this->stack + 0x8000); // EBP - uint32_t rEBP = stack32; + uint32_t rEBP = stack32; - //stack32--; - *(--stack32) = 0; // EAX - *(--stack32) = 0; // ECX - *(--stack32) = 0; // EDX - *(--stack32) = 0; // EBX - *(--stack32) = 0; // ESP - *(--stack32) = rEBP; // EBP - *(--stack32) = 0; // ESI - *(--stack32) = 0; // EDI - stack32--; - *(--stack32) = &catchall_return; // cachall_return - stack32--; + //stack32--; + *(--stack32) = 0; // EAX + *(--stack32) = 0; // ECX + *(--stack32) = 0; // EDX + *(--stack32) = 0; // EBX + *(--stack32) = 0; // ESP + *(--stack32) = rEBP; // EBP + *(--stack32) = 0; // ESI + *(--stack32) = 0; // EDI + stack32--; + *(--stack32) = &catchall_return; // cachall_return + stack32--; - this->kernelStackPtr = stack32; + this->kernelStackPtr = stack32; - load_file(filename, program_data); + //load_file(filename, program_data); + filereader->read(filesize, program_data); - asm ("mov %0, %%cr3" : : "r" (pCR3)); + asm ("mov %0, %%cr3" : : "r" (pCR3)); + } } Process::~Process() { diff --git a/src/kernel/process.h b/src/kernel/process.h index 65fe9c1..c056d0f 100644 --- a/src/kernel/process.h +++ b/src/kernel/process.h @@ -46,7 +46,7 @@ public: Process(uint32_t PID, void* stack, PageDirectory* page_directory, PageMap* phys, PageMap* virt, uint32_t virt_alloc_base); Process(uint32_t PID); - Process(uint32_t PID, PageDirectory* inherit, uint32_t inheritBase, char* filename); + Process(uint32_t PID, PageDirectory* inherit, uint32_t inheritBase, uint32_t fh); ~Process(); // Iterate through allocations and free those; delete stack diff --git a/src/kernel/stdio/circularrwbuffer.cpp b/src/kernel/stdio/circularrwbuffer.cpp index 047ed62..cb0f497 100644 --- a/src/kernel/stdio/circularrwbuffer.cpp +++ b/src/kernel/stdio/circularrwbuffer.cpp @@ -11,7 +11,7 @@ CircularRWBuffer::CircularRWBuffer(uint32_t reader, uint32_t writer) this->writePtr = 0; } -int CircularRWBuffer::write(uint32_t count, uint8_t* buffer) { +uint32_t CircularRWBuffer::write(uint32_t count, uint8_t* buffer) { int i=0; while (i < count) { this->buffer[this->writePtr] = buffer[i]; @@ -24,7 +24,7 @@ int CircularRWBuffer::write(uint32_t count, uint8_t* buffer) { return i; } -int CircularRWBuffer::read(uint32_t count, uint8_t* buffer) { +uint32_t CircularRWBuffer::read(uint32_t count, uint8_t* buffer) { int i=0; while (i < count) { if (this->readPtr == this->writePtr) @@ -37,4 +37,8 @@ int CircularRWBuffer::read(uint32_t count, uint8_t* buffer) { i++; } return i; +} + +uint32_t CircularRWBuffer::size() { + return 0; } \ No newline at end of file diff --git a/src/kernel/stdio/circularrwbuffer.h b/src/kernel/stdio/circularrwbuffer.h index a179f40..52bb153 100644 --- a/src/kernel/stdio/circularrwbuffer.h +++ b/src/kernel/stdio/circularrwbuffer.h @@ -12,8 +12,9 @@ private: public: CircularRWBuffer(uint32_t reader, uint32_t writer); - int read(uint32_t count, uint8_t* buffer) override; - int write(uint32_t count, uint8_t* buffer) override; + uint32_t read(uint32_t count, uint8_t* buffer) override; + uint32_t write(uint32_t count, uint8_t* buffer) override; + uint32_t size() override; }; #endif \ No newline at end of file diff --git a/src/kernel/stdio/readwriter.cpp b/src/kernel/stdio/readwriter.cpp index b771ce9..c2c1043 100644 --- a/src/kernel/stdio/readwriter.cpp +++ b/src/kernel/stdio/readwriter.cpp @@ -12,8 +12,9 @@ void ReadWriter::giveWritePerm(uint32_t PID) { this->allowedWrite.append(PID); } -int ReadWriter::read(uint32_t count, uint8_t* buffer){} -int ReadWriter::write(uint32_t count, uint8_t* buffer){} +uint32_t ReadWriter::read(uint32_t count, uint8_t* buffer){} +uint32_t ReadWriter::write(uint32_t count, uint8_t* buffer){} +uint32_t ReadWriter::size(){} bool ReadWriter::canRead(uint32_t PID) { if (this->owner == PID) diff --git a/src/kernel/stdio/readwriter.h b/src/kernel/stdio/readwriter.h index 65b81b8..d32738c 100644 --- a/src/kernel/stdio/readwriter.h +++ b/src/kernel/stdio/readwriter.h @@ -15,8 +15,9 @@ public: void giveReadPerm(uint32_t PID); void giveWritePerm(uint32_t PID); - virtual int read(uint32_t count, uint8_t* buffer); - virtual int write(uint32_t count, uint8_t* buffer); + virtual uint32_t read(uint32_t count, uint8_t* buffer); + virtual uint32_t write(uint32_t count, uint8_t* buffer); + virtual uint32_t size(); uint32_t getOwner(); bool canRead(uint32_t PID); bool canWrite(uint32_t PID); diff --git a/src/kernel/terminal.cpp b/src/kernel/terminal.cpp index c9f30c5..eff258b 100644 --- a/src/kernel/terminal.cpp +++ b/src/kernel/terminal.cpp @@ -182,7 +182,7 @@ void Terminal::printf(const char* string, ...) { va_end(ptr); } -int Terminal::write(uint32_t count, uint8_t* string) { +uint32_t Terminal::write(uint32_t count, uint8_t* string) { /*char* buf = new char[count+1]; for (int i=0;iset_curpos(this->cur_x, this->cur_y); } -int Terminal::read(uint32_t count, uint8_t* buffer) {} +uint32_t Terminal::read(uint32_t count, uint8_t* buffer) {} void Terminal::clear_screen() { for (int i=0; i < width * height * pages; i++) { diff --git a/src/kernel/terminal.h b/src/kernel/terminal.h index 5f1646d..5ee063e 100644 --- a/src/kernel/terminal.h +++ b/src/kernel/terminal.h @@ -38,8 +38,8 @@ public: void printf(const char* string, ...); - int write(uint32_t count, uint8_t* buffer) override; - int read(uint32_t count, uint8_t* buffer) override; + uint32_t write(uint32_t count, uint8_t* buffer) override; + uint32_t read(uint32_t count, uint8_t* buffer) override; void clear_screen(); void set_curpos(int x, int y); diff --git a/src/world/world.c b/src/world/world.c index 0b507d9..ad8ff7c 100644 --- a/src/world/world.c +++ b/src/world/world.c @@ -168,15 +168,16 @@ int main() { for (int i=0; i<80;i++) write(1, 0, &plus); - char* hello_bin = "HELLO BIN"; - uint32_t p1 = fork(hello_bin); - uint32_t p2 = fork(hello_bin); - + uint32_t program = fopen("hello.bin"); + uint32_t p1 = fork(program); uint32_t p1out = bindStdout(p1); uint32_t p1in = bindStdin(p1); - + fclose(program); + program = fopen("hello.bin"); + uint32_t p2 = fork(program); uint32_t p2out = bindStdout(p2); uint32_t p2in = bindStdin(p2); + fclose(program); procbuffer b1 = { .buffer = localalloc(21 * 38),