67886b0c5a 
								
							 
						 
						
							
							
								
								Kernel: Move V2P and P2V to Memory/Types.h  
							
							
							
						 
						
							2023-05-30 23:57:03 +03:00  
				
					
						
							
							
								 
						
							
								56eb6fb4ce 
								
							 
						 
						
							
							
								
								Kernel: PageTable::map_range_at maps correctly the last page  
							
							
							
						 
						
							2023-05-30 23:56:07 +03:00  
				
					
						
							
							
								 
						
							
								81cf389754 
								
							 
						 
						
							
							
								
								Kernel: Booting with higher half kernel gets to Heap initialization  
							
							
							
						 
						
							2023-05-30 22:21:12 +03:00  
				
					
						
							
							
								 
						
							
								0907965dc5 
								
							 
						 
						
							
							
								
								Kernel: start work on higher half kernel  
							
							
							
						 
						
							2023-05-30 08:00:17 +03:00  
				
					
						
							
							
								 
						
							
								210d90ec79 
								
							 
						 
						
							
							
								
								Kernel: We now identity map full GiB in boot.S  
							
							... 
							
							
							
							The paging structure is pre-built so no unnecessary calculations are done 
							
						 
						
							2023-05-30 00:08:52 +03:00  
				
					
						
							
							
								 
						
							
								8bea18a6f2 
								
							 
						 
						
							
							
								
								Kernel: Remove unused includes of CriticalScope  
							
							
							
						 
						
							2023-05-29 21:15:55 +03:00  
				
					
						
							
							
								 
						
							
								861966eed6 
								
							 
						 
						
							
							
								
								Kernel: Remove unnecessary usages of PageTableScope  
							
							... 
							
							
							
							This should be used as few times as possible since it calls 'cli' 
							
						 
						
							2023-05-29 21:11:29 +03:00  
				
					
						
							
							
								 
						
							
								5bb1f2a48c 
								
							 
						 
						
							
							
								
								Kernel: Rename MMU to PageTable  
							
							... 
							
							
							
							This is more descriptive name for what it actually represents 
							
						 
						
							2023-05-29 21:06:09 +03:00  
				
					
						
							
							
								 
						
							
								fb17af4844 
								
							 
						 
						
							
							
								
								Kernel/LibC: opening standard files is done in libc  
							
							
							
						 
						
							2023-05-29 20:21:19 +03:00  
				
					
						
							
							
								 
						
							
								b8ec8918b7 
								
							 
						 
						
							
							
								
								Kernel: We can't lock the MMU lock in load()  
							
							... 
							
							
							
							It needs to be callable always by scheduler 
							
						 
						
							2023-05-29 19:39:35 +03:00  
				
					
						
							
							
								 
						
							
								ff83f967d8 
								
							 
						 
						
							
							
								
								Kernel: Make RecursiveSpinLock thread safe  
							
							... 
							
							
							
							also SpinLock is now implemented with gcc builtins 
							
						 
						
							2023-05-29 19:38:09 +03:00  
				
					
						
							
							
								 
						
							
								998999a755 
								
							 
						 
						
							
							
								
								Kernel: Add SYS_SLEEP  
							
							
							
						 
						
							2023-05-28 22:34:48 +03:00  
				
					
						
							
							
								 
						
							
								09666adc53 
								
							 
						 
						
							
							
								
								Kernel: fork() now copies allocations through FixedWidthAllocator  
							
							
							
						 
						
							2023-05-28 21:34:35 +03:00  
				
					
						
							
							
								 
						
							
								ec73db0057 
								
							 
						 
						
							
							
								
								Kernel: Move page macros to Types.h  
							
							
							
						 
						
							2023-05-28 21:03:08 +03:00  
				
					
						
							
							
								 
						
							
								833642d405 
								
							 
						 
						
							
							
								
								Kernel: ISR will now crash userspace process instead of panicing kernel  
							
							
							
						 
						
							2023-05-28 20:53:10 +03:00  
				
					
						
							
							
								 
						
							
								f04399c3a0 
								
							 
						 
						
							
							
								
								Kernel: fork() now copies allocation done through GeneralAllocator  
							
							
							
						 
						
							2023-05-28 20:37:39 +03:00  
				
					
						
							
							
								 
						
							
								f2d767b799 
								
							 
						 
						
							
							
								
								Kernel: Add bareboness fork() function  
							
							
							
						 
						
							2023-05-28 18:08:49 +03:00  
				
					
						
							
							
								 
						
							
								3e93dae53c 
								
							 
						 
						
							
							
								
								Kernel: Add invalidate() to MMU  
							
							
							
						 
						
							2023-05-28 18:05:49 +03:00  
				
					
						
							
							
								 
						
							
								187bb046aa 
								
							 
						 
						
							
							
								
								Kernel: fix MMU::map_page_at()  
							
							... 
							
							
							
							We used to only reassign if flags changed 
							
						 
						
							2023-05-28 17:57:05 +03:00  
				
					
						
							
							
								 
						
							
								b021d3eebd 
								
							 
						 
						
							
							
								
								Kernel: Processes and Threads use VirtualRange memory allocations  
							
							
							
						 
						
							2023-05-28 17:48:34 +03:00  
				
					
						
							
							
								 
						
							
								15842db83e 
								
							 
						 
						
							
							
								
								Kernel: Move PhysicalRange to its own file and add VirtualRange  
							
							
							
						 
						
							2023-05-28 17:48:34 +03:00  
				
					
						
							
							
								 
						
							
								869de7283f 
								
							 
						 
						
							
							
								
								Kernel: MMU::get() is now MMU::kernel  
							
							... 
							
							
							
							MMU is can now be locked with RecursiveSpinLock.
Scheduler now has get_current_tid() that works before the Scheduler
is initialized. This allows RecursiveSpinLock usage early on. 
							
						 
						
							2023-05-28 16:18:18 +03:00  
				
					
						
							
							
								 
						
							
								eb24d32383 
								
							 
						 
						
							
							
								
								Kernel: Directory listing is working again  
							
							
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								565e3db22d 
								
							 
						 
						
							
							
								
								Kernel: kmalloc debug_dump is marked [[maybe_unused]]  
							
							
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								faf14b880e 
								
							 
						 
						
							
							
								
								LibC: Rewrite all the headers.  
							
							... 
							
							
							
							We now have more or less posix issue 2018 conforming libc headers.
This was a really time consuming and boring operation but it had to
be done.
Now we get to actually start implementing libc :) 
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								27147790fd 
								
							 
						 
						
							
							
								
								Userspace: Start work on shell  
							
							
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								1658e925f2 
								
							 
						 
						
							
							
								
								Kernel: Add bareboness possibility to set termios  
							
							
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								80d9f6131b 
								
							 
						 
						
							
							
								
								Kernel/LibC: move file offset back to kernel  
							
							... 
							
							
							
							This makes keeping track of offsets easier and more proper 
							
						 
						
							2023-05-26 22:31:21 +03:00  
				
					
						
							
							
								 
						
							
								e0a72defa2 
								
							 
						 
						
							
							
								
								Kernel: Add argc and argv to process entry  
							
							
							
						 
						
							2023-05-16 00:27:49 +03:00  
				
					
						
							
							
								 
						
							
								e0a7e242f8 
								
							 
						 
						
							
							
								
								Kernel: Add MMUScope  
							
							... 
							
							
							
							This disables interrupts and loads specified mmu for the
scope it lives in 
							
						 
						
							2023-05-16 00:26:39 +03:00  
				
					
						
							
							
								 
						
							
								6acb86c14b 
								
							 
						 
						
							
							
								
								Kernel: MMU keeps track of the current  
							
							
							
						 
						
							2023-05-16 00:26:39 +03:00  
				
					
						
							
							
								 
						
							
								ec316391c5 
								
							 
						 
						
							
							
								
								Kernel: argc is passed as zero to userspace  
							
							
							
						 
						
							2023-05-11 18:28:32 +03:00  
				
					
						
							
							
								 
						
							
								177b205c48 
								
							 
						 
						
							
							
								
								BuildSystem: userspace has cmake target  
							
							
							
						 
						
							2023-05-11 16:19:53 +03:00  
				
					
						
							
							
								 
						
							
								729ff267d7 
								
							 
						 
						
							
							
								
								LibC: add function declarations to sys/stat.h  
							
							
							
						 
						
							2023-05-11 15:11:33 +03:00  
				
					
						
							
							
								 
						
							
								ff2e2937a5 
								
							 
						 
						
							
							
								
								Kernel: Remove offset from OpenFileDescriptor  
							
							... 
							
							
							
							This is now handled on the libc side. There might be reasons to
have it in kernel side, but for simplicity's sake I'm moving it
to libc for now :) 
							
						 
						
							2023-05-09 20:31:22 +03:00  
				
					
						
							
							
								 
						
							
								512be884ed 
								
							 
						 
						
							
							
								
								Kernel: Add barebones GeneralAllocator for >4096B  
							
							
							
						 
						
							2023-05-08 22:10:49 +03:00  
				
					
						
							
							
								 
						
							
								f1667b398a 
								
							 
						 
						
							
							
								
								Kernel: FixedWidthAllocator operates on MMU  
							
							... 
							
							
							
							Instead of Process* we use MMU& in FixedWidthAllocator since it is
everything it actually needs :) 
							
						 
						
							2023-05-08 00:06:56 +03:00  
				
					
						
							
							
								 
						
							
								b0ec0f1a1a 
								
							 
						 
						
							
							
								
								Kernel: We add FixedWidthAllocators on demand  
							
							... 
							
							
							
							On SYS_ALLOC we will add a new FixedWidthAllocator if the old ones
are already full or we don't have one with proper size. This allows
arbitary number of allocations as long as you have enough memory
available :)
Next I will be writing a general allocator for allocations larger
than 4096 bytes which should make SYS_ALLOC syscall complete :) 
							
						 
						
							2023-05-07 23:57:01 +03:00  
				
					
						
							
							
								 
						
							
								12e42f40c5 
								
							 
						 
						
							
							
								
								Kernel/LibC: add free function for FixedWidthAllocator  
							
							... 
							
							
							
							I have to rework the syscall API and allocators in process. For
now this works well enough :) 
							
						 
						
							2023-05-07 01:21:50 +03:00  
				
					
						
							
							
								 
						
							
								890aa9aa15 
								
							 
						 
						
							
							
								
								BuildSystem: linker -O2 doesn't do anything? hopefully  
							
							
							
						 
						
							2023-05-06 19:58:08 +03:00  
				
					
						
							
							
								 
						
							
								bcfd838131 
								
							 
						 
						
							
							
								
								Kernel: Add basic fixed width allocator for userspace  
							
							... 
							
							
							
							We have to move process stacks to the general heap and maybe map
kernel to higher half. 
							
						 
						
							2023-05-06 19:58:08 +03:00  
				
					
						
							
							
								 
						
							
								9c07add00f 
								
							 
						 
						
							
							
								
								Kernel: Invalid physical addresses from heap are specified now by 0  
							
							
							
						 
						
							2023-05-06 17:34:22 +03:00  
				
					
						
							
							
								 
						
							
								ab8aac7dcf 
								
							 
						 
						
							
							
								
								Kernel: GDT tss selector is now 16 bit value  
							
							
							
						 
						
							2023-05-06 17:34:22 +03:00  
				
					
						
							
							
								 
						
							
								f36b94d039 
								
							 
						 
						
							
							
								
								Kernel: MMU can now provide info about virtual address space  
							
							
							
						 
						
							2023-05-06 17:34:22 +03:00  
				
					
						
							
							
								 
						
							
								92daa831d1 
								
							 
						 
						
							
							
								
								Kernel: ISRs now print pid and tid  
							
							
							
						 
						
							2023-05-06 00:10:15 +03:00  
				
					
						
							
							
								 
						
							
								e7a170c89f 
								
							 
						 
						
							
							
								
								Kernel: 64 bit MMU now properly identity maps kernel  
							
							
							
						 
						
							2023-05-05 14:19:28 +03:00  
				
					
						
							
							
								 
						
							
								3c5d3eb8ad 
								
							 
						 
						
							
							
								
								Kernel: TTY input process is now single instance  
							
							... 
							
							
							
							Process sends key events to the active (currently only) tty 
							
						 
						
							2023-04-30 16:11:14 +03:00  
				
					
						
							
							
								 
						
							
								55bb0084aa 
								
							 
						 
						
							
							
								
								Kernel: namespace and function renames  
							
							... 
							
							
							
							MMU moved to namespace kernel
Kernel::Memory::Heap moved to just Kernel
MMU::map_{page,range} renamed to identity_map_{page,range}
Add MMU::get_page_flags 
							
						 
						
							2023-04-28 14:48:38 +03:00  
				
					
						
							
							
								 
						
							
								acf5660090 
								
							 
						 
						
							
							
								
								Kernel: Add set_tss_stack() to 32 bit  
							
							
							
						 
						
							2023-04-28 14:44:23 +03:00  
				
					
						
							
							
								 
						
							
								9d7530662f 
								
							 
						 
						
							
							
								
								Kernel: dprintln file name is now relative  
							
							... 
							
							
							
							This makes file names much shorter 
							
						 
						
							2023-04-28 14:43:19 +03:00  
				
					
						
							
							
								 
						
							
								a22caa38d2 
								
							 
						 
						
							
							
								
								Kernel: Scheduler updates tss stack on thread execution  
							
							
							
						 
						
							2023-04-25 14:49:50 +03:00  
				
					
						
							
							
								 
						
							
								dc0f8b383f 
								
							 
						 
						
							
							
								
								Kernel: Usespace threads now have an interrupt stack  
							
							
							
						 
						
							2023-04-25 14:49:18 +03:00  
				
					
						
							
							
								 
						
							
								f1a0625b61 
								
							 
						 
						
							
							
								
								Kernel: TSS stack can be set after initialization  
							
							
							
						 
						
							2023-04-25 14:48:12 +03:00  
				
					
						
							
							
								 
						
							
								02b961fd7e 
								
							 
						 
						
							
							
								
								Kernel: Stack pointer out of bounds now panics with a message  
							
							
							
						 
						
							2023-04-25 13:40:55 +03:00  
				
					
						
							
							
								 
						
							
								6e01e04922 
								
							 
						 
						
							
							
								
								Kernel: Fix bug in Process::create_userspace()  
							
							... 
							
							
							
							We used to write more than we needed to. This could lead to unwanted
page faults 
							
						 
						
							2023-04-25 13:21:28 +03:00  
				
					
						
							
							
								 
						
							
								b7c2ea8d46 
								
							 
						 
						
							
							
								
								Kernel: Fix possible dead lock in Process::read()  
							
							
							
						 
						
							2023-04-23 14:46:18 +03:00  
				
					
						
							
							
								 
						
							
								cd74b2167d 
								
							 
						 
						
							
							
								
								LibC: Write mostly functioning stdio  
							
							
							
						 
						
							2023-04-23 14:32:37 +03:00  
				
					
						
							
							
								 
						
							
								9b2a577fc3 
								
							 
						 
						
							
							
								
								Kernel: Add ASSERTion to Process::exit()  
							
							... 
							
							
							
							This is just so I don't forget that exit can currently only
be called on the executing thread itself 
							
						 
						
							2023-04-22 19:05:27 +03:00  
				
					
						
							
							
								 
						
							
								2dd09163e6 
								
							 
						 
						
							
							
								
								Kernel: Process can now load 32 bit elf files on i386  
							
							... 
							
							
							
							We are page faulting on process exit but I'm investigating
the reason. 
							
						 
						
							2023-04-22 19:03:30 +03:00  
				
					
						
							
							
								 
						
							
								fb6add2b4a 
								
							 
						 
						
							
							
								
								Kernel: Fix 32 bit MMU  
							
							
							
						 
						
							2023-04-22 18:22:39 +03:00  
				
					
						
							
							
								 
						
							
								48445f12ac 
								
							 
						 
						
							
							
								
								Kernel: More proper paging in Elf loading  
							
							
							
						 
						
							2023-04-22 18:17:44 +03:00  
				
					
						
							
							
								 
						
							
								792fad2a03 
								
							 
						 
						
							
							
								
								Kernel: d{print,warn,error}ln(...) now has a spinlock  
							
							
							
						 
						
							2023-04-22 17:58:51 +03:00  
				
					
						
							
							
								 
						
							
								cc04990ce3 
								
							 
						 
						
							
							
								
								Kernel: Process now frees up its pages on destruction  
							
							
							
						 
						
							2023-04-22 16:54:46 +03:00  
				
					
						
							
							
								 
						
							
								7530482cc2 
								
							 
						 
						
							
							
								
								Kernel: Cleanup process creation for userspace  
							
							
							
						 
						
							2023-04-22 16:51:50 +03:00  
				
					
						
							
							
								 
						
							
								33d8c518e9 
								
							 
						 
						
							
							
								
								Kernel: Fix some deadlocks in the Process  
							
							
							
						 
						
							2023-04-22 16:19:57 +03:00  
				
					
						
							
							
								 
						
							
								e0ce2394fe 
								
							 
						 
						
							
							
								
								Kernel: Remove obsolete userspace stuff from kernel  
							
							
							
						 
						
							2023-04-22 15:38:45 +03:00  
				
					
						
							
							
								 
						
							
								fadce063a7 
								
							 
						 
						
							
							
								
								Kernel: Usespace programs are now ran through ELF files  
							
							... 
							
							
							
							only 64 bit elf files are supported for now. 
							
						 
						
							2023-04-22 15:35:32 +03:00  
				
					
						
							
							
								 
						
							
								26fe6ad898 
								
							 
						 
						
							
							
								
								Kernel: kmalloc does not dump stack trace  
							
							... 
							
							
							
							dump_stack_trace() page faults and i dont feel like debugging this
now :) 
							
						 
						
							2023-04-21 13:45:13 +03:00  
				
					
						
							
							
								 
						
							
								fc71d2f7c4 
								
							 
						 
						
							
							
								
								Kernel: Don't call 'cli' on interrupt  
							
							... 
							
							
							
							This is automatically done because we are using interrupt gates
in the IDT 
							
						 
						
							2023-04-21 11:18:08 +03:00  
				
					
						
							
							
								 
						
							
								35e949ef5e 
								
							 
						 
						
							
							
								
								Kernel: Fix syscall return value in 32 bit  
							
							
							
						 
						
							2023-04-21 11:08:02 +03:00  
				
					
						
							
							
								 
						
							
								9c506ef85b 
								
							 
						 
						
							
							
								
								Kernel: Stack pointer is validated when updated  
							
							... 
							
							
							
							This allows us not to fail stack pointer when in syscall since
interrupts use their own stack 
							
						 
						
							2023-04-21 10:40:24 +03:00  
				
					
						
							
							
								 
						
							
								b1c7af38d0 
								
							 
						 
						
							
							
								
								Kernel: Add barebones per process virtual addresses  
							
							... 
							
							
							
							We now assign every (userspace) process its own MMU which we load
in scheduler. This allows every process to have separate virtual
address space.
This is very hackish implementations but it works for now 
							
						 
						
							2023-04-20 00:45:41 +03:00  
				
					
						
							
							
								 
						
							
								ea0c9b639f 
								
							 
						 
						
							
							
								
								Kernel: Add some bareboness functionality to map virtual addresses  
							
							
							
						 
						
							2023-04-19 23:51:36 +03:00  
				
					
						
							
							
								 
						
							
								0030f035be 
								
							 
						 
						
							
							
								
								Kernel: Rename MMU::{un,}allocate... to MMU::{un,}map  
							
							... 
							
							
							
							This is more appropriate name for the behaviour :D 
							
						 
						
							2023-04-19 21:50:30 +03:00  
				
					
						
							
							
								 
						
							
								c26529ae86 
								
							 
						 
						
							
							
								
								Kernel: kmalloc will always print debug on failed alloc  
							
							
							
						 
						
							2023-04-19 18:05:01 +03:00  
				
					
						
							
							
								 
						
							
								e8a0df54b1 
								
							 
						 
						
							
							
								
								Kernel: ATAController will fail to initialize in native mode  
							
							
							
						 
						
							2023-04-19 17:29:36 +03:00  
				
					
						
							
							
								 
						
							
								33393335c8 
								
							 
						 
						
							
							
								
								Kernel: PCI devices now report their prog_if  
							
							
							
						 
						
							2023-04-19 16:43:05 +03:00  
				
					
						
							
							
								 
						
							
								c5b02bb9f5 
								
							 
						 
						
							
							
								
								Kernel: Shell fix file reading  
							
							... 
							
							
							
							We were reading 8 bytes at a time instead of the 1024 we were
supposed to :DD 
							
						 
						
							2023-04-19 14:09:23 +03:00  
				
					
						
							
							
								 
						
							
								a1047918d2 
								
							 
						 
						
							
							
								
								Kernel: Shell now has exit() command  
							
							
							
						 
						
							2023-04-19 12:53:09 +03:00  
				
					
						
							
							
								 
						
							
								fd81e31050 
								
							 
						 
						
							
							
								
								Kernel: Fix Process::exit() and where it is called from  
							
							... 
							
							
							
							cksum doesn't seem to work anymore on big files. I have to look
into this. It locks up after couple of seconds... 
							
						 
						
							2023-04-19 12:52:21 +03:00  
				
					
						
							
							
								 
						
							
								dcce18799f 
								
							 
						 
						
							
							
								
								Kernel: We now launch Shell again on boot  
							
							... 
							
							
							
							Adding this just before push :D 
							
						 
						
							2023-04-19 00:41:24 +03:00  
				
					
						
							
							
								 
						
							
								a9a15ea2c0 
								
							 
						 
						
							
							
								
								Kernel: init2 is now launched as a process instead of thread  
							
							... 
							
							
							
							Also only process can now add threads to scheduler. Nobody should
have raw access to scheduler and everything should be through
Process::current() or irqs (reschedules) 
							
						 
						
							2023-04-19 00:39:06 +03:00  
				
					
						
							
							
								 
						
							
								d63716db96 
								
							 
						 
						
							
							
								
								Kernel: Process is not reference counted any more  
							
							... 
							
							
							
							This was not necessary and it made things needlessly complicated 
							
						 
						
							2023-04-19 00:34:18 +03:00  
				
					
						
							
							
								 
						
							
								96ac072166 
								
							 
						 
						
							
							
								
								Kernel: Heap allows us to take free pages.  
							
							... 
							
							
							
							The API is kinda weird and will probably be reworked in near future
but this will work for now :) 
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								295a27f16a 
								
							 
						 
						
							
							
								
								Kernel: Panic wont print stacktrace if it has already paniced  
							
							... 
							
							
							
							This prevents stack trace dump to panic and loop 
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								88f60b5e41 
								
							 
						 
						
							
							
								
								Kernel: Map all ACPI tables on initialization  
							
							... 
							
							
							
							This makes their usage much easier and less error prone
They won't mapped be processes when we get to there, so this won't be
a problem 
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								d23604b0d5 
								
							 
						 
						
							
							
								
								Kernel: Handle some Heap edge cases  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								c5347e6707 
								
							 
						 
						
							
							
								
								Kernel: Reorder boot initialization  
							
							... 
							
							
							
							We now create the TTY as soon as possible so we can show console
output without serial port. 
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								bf0c7b9ae8 
								
							 
						 
						
							
							
								
								Kernel: Heap implementation can now give free pages from all of RAM  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								0374b68fa1 
								
							 
						 
						
							
							
								
								Kernel: Remove unused file  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								633929629c 
								
							 
						 
						
							
							
								
								Kernel: Start working on heap  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								6a3b3213cf 
								
							 
						 
						
							
							
								
								Kernel: Kmalloc now has its memory statically allocated  
							
							... 
							
							
							
							We don't use the memory map given by bootloader since this automatically
maps the memory to a available space. 
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								fdb4eb6042 
								
							 
						 
						
							
							
								
								Kernel: Move kmalloc and MMU to Memory directory  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								998ae511a3 
								
							 
						 
						
							
							
								
								LibELF: Start implementing elf library  
							
							
							
						 
						
							2023-04-18 10:18:15 +03:00  
				
					
						
							
							
								 
						
							
								3f9d6f0311 
								
							 
						 
						
							
							
								
								LibC: add needed stubs to build executables with our compiler  
							
							
							
						 
						
							2023-04-12 17:53:02 +03:00  
				
					
						
							
							
								 
						
							
								8ee63f8264 
								
							 
						 
						
							
							
								
								Kernel: We can create basic userspace processes  
							
							... 
							
							
							
							These are still allocated on the kernel memory 
							
						 
						
							2023-04-12 17:52:36 +03:00  
				
					
						
							
							
								 
						
							
								34358b8471 
								
							 
						 
						
							
							
								
								Kernel: Scheduler can now terminate processes threads  
							
							
							
						 
						
							2023-04-12 17:49:04 +03:00  
				
					
						
							
							
								 
						
							
								5b1af4ec47 
								
							 
						 
						
							
							
								
								Kernel: Debug::dump_stack_trace now 'detects' repeating function  
							
							
							
						 
						
							2023-04-12 01:32:41 +03:00  
				
					
						
							
							
								 
						
							
								071d7af58a 
								
							 
						 
						
							
							
								
								Kernel: kmalloc does not check for corruptiong unless it cannot allocate  
							
							... 
							
							
							
							We 'don't care' if kmalloc is corrupted unless it prevents us from
allocating memory. Scheduler should be catching stack overflows either
way and is much more efficient 
							
						 
						
							2023-04-12 00:24:02 +03:00  
				
					
						
							
							
								 
						
							
								3201c3654e 
								
							 
						 
						
							
							
								
								Kernel: Threads now use only 4 KiB stack :)  
							
							
							
						 
						
							2023-04-12 00:22:08 +03:00