ladybird/Kernel/kmalloc.h

#pragma once

void kmalloc_init();
void *kmalloc(dword size) __attribute__ ((malloc));
void* kmalloc_eternal(size_t) __attribute__ ((malloc));
void* kmalloc_page_aligned(size_t) __attribute__ ((malloc));
void* kmalloc_aligned(size_t, size_t alignment) __attribute__ ((malloc));
void kfree(void*);
void kfree_aligned(void*);

bool is_kmalloc_address(void*);

extern volatile size_t sum_alloc;
extern volatile size_t sum_free;
extern volatile size_t kmalloc_sum_eternal;
extern volatile size_t kmalloc_sum_page_aligned;

inline void* operator new(size_t, void* p) { return p; }
inline void* operator new[](size_t, void* p) { return p; }
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work. 2018-10-16 11:01:38 +02:00			`#pragma once`

			`void kmalloc_init();`
Make bash-2.05b build with minimal changes. This is really neat. :^) 2018-11-17 00:11:08 +01:00			`void *kmalloc(dword size) __attribute__ ((malloc));`
Add a kmalloc_eternal() for things that will never be destroyed. 2018-10-31 23:19:15 +01:00			`void* kmalloc_eternal(size_t) __attribute__ ((malloc));`
Give each task its own page directory. This isn't finished but I'll commit as I go. We need to get to where context switching only needs to change CR3 and everything's ready to go. My basic idea is: - The first 4 kB is off-limits. This catches null dereferences. - Up to the 4 MB mark is identity-mapped and kernel-only. - The rest is available to everyone! While the first 4 MB is only available to the kernel, it's still mapped in every process, for convenience when entering the kernel. 2018-11-01 09:01:51 +01:00			`void* kmalloc_page_aligned(size_t) __attribute__ ((malloc));`
Add slightly better kmalloc_aligned() and kfree_aligned(). Process page directories can now actually be freed. This could definitely be implemented in a nicer, less wasteful way, but this works for now. The spawn stress test can now run for a lot longer but eventually dies due to kmalloc running out of memory. 2018-12-26 21:31:46 +01:00			`void* kmalloc_aligned(size_t, size_t alignment) __attribute__ ((malloc));`
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work. 2018-10-16 11:01:38 +02:00			`void kfree(void*);`
Add slightly better kmalloc_aligned() and kfree_aligned(). Process page directories can now actually be freed. This could definitely be implemented in a nicer, less wasteful way, but this works for now. The spawn stress test can now run for a lot longer but eventually dies due to kmalloc running out of memory. 2018-12-26 21:31:46 +01:00			`void kfree_aligned(void*);`
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work. 2018-10-16 11:01:38 +02:00
Greatly improve /proc/PID/stack by tracing the ebp frame chain. I also added a generator cache to FileHandle. This way, multiple reads to a generated file (i.e in a synthfs) can transparently handle multiple calls to read() without the contents changing between calls. The cache is discarded at EOF (or when the FileHandle is destroyed.) 2018-10-27 00:14:24 +02:00			`bool is_kmalloc_address(void*);`

Make it possible to build the Kernel on a macOS host. It still requires an ELF compiler and linker, but at least it builds. I need to get rid of the "Unix" namespace. This does a lot of that. 2018-12-02 23:34:50 +01:00			`extern volatile size_t sum_alloc;`
			`extern volatile size_t sum_free;`
			`extern volatile size_t kmalloc_sum_eternal;`
			`extern volatile size_t kmalloc_sum_page_aligned;`
Import the "gerbert" kernel I worked on earlier this year. It's a lot crappier than I remembered it. It's gonna need a lot of work. 2018-10-16 11:01:38 +02:00
			`inline void* operator new(size_t, void* p) { return p; }`
			`inline void* operator new[](size_t, void* p) { return p; }`