kamkow1/my-os-project2
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: kamkow1:f5dae4984d76cb467e95c6bd73186f1c55844696
Branches Tags
kamkow1:master
..
compare: kamkow1:566b35f4d588e137284ed740cb846cd4fe07ee54
Branches Tags
kamkow1:master

3 Commits
f5dae4984d ... 566b35f4d5

Author SHA1 Message Date
kamkow1
566b35f4d5 Big code refactor, get rid of HAL entirely 2025-11-11 21:26:27 +01:00
kamkow1
7015bc9576 Decouple I/O from HAL 2025-11-11 19:59:01 +01:00
kamkow1
344952fb5f Move string functions/utils from HAL to std/string 2025-11-11 19:54:09 +01:00
88 changed files with 673 additions and 739 deletions
Expand all files Collapse all files

6
kernel/FastLZ/6unpack_mem.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include "hal/hal.h"
#include "fastlz.h"
#include "FastLZ/fastlz.h"
#include "std/string.h"
#define SIXPACK_OK 0
#define SIXPACK_ERR_MAGIC -1
@ -93,7 +93,7 @@ int sixpack_decompress_mem(const uint8_t *input, size_t in_size,
/* Stored (uncompressed) */
if (written + size > out_cap)
return SIXPACK_ERR_NO_SPACE;
hal_memcpy(output + written, chunk_data, size);
memcpy(output + written, chunk_data, size);
written += size;
} else if (opts == 1) {
/* FastLZ compressed */

6
kernel/Makefile
View File

@ -46,8 +46,6 @@ SRCFILES += $(call GRABSRC, \
fs/portlfs \
baseimg \
proc \
hal \
hal/$(ARCH) \
std \
flanterm/src \
flanterm/src/flanterm_backends \
@ -60,6 +58,10 @@ SRCFILES += $(call GRABSRC, \
time \
diskpart \
FastLZ \
io \
intr \
cpu \
vmm \
)
CFILES := $(call GET_CFILES, $(SRCFILES))

15
kernel/assert.h
View File

@ -1,15 +0,0 @@
#ifndef ASSERT_H_
#define ASSERT_H_
#include "kprintf.h"
#include "hal/hal.h"
#define ASSERT(mod, cond, fmt, ...) \
do { \
if (!(cond)) { \
ERR(mod, fmt, ##__VA_ARGS__); \
hal_hang(); \
} \
} while(0)
#endif // ASSERT_H_

13
kernel/baseimg/baseimg.c
View File

@ -1,14 +1,15 @@
#include <stdint.h>
#include <stddef.h>
#include <limine.h>
#include "baseimg.h"
#include "baseimg/baseimg.h"
#include "bootinfo/bootinfo.h"
#include "kprintf.h"
#include "util/util.h"
#include "hal/hal.h"
#include "dlmalloc/malloc.h"
#include "FastLZ/fastlz.h"
#include "FastLZ/6unpack_mem.h"
#include "std/string.h"
#include "cpu/hang.h"
#include "kprintf.h"
#define BASEIMG_DECOMPRESSED (1024*1024*4)
@ -29,7 +30,7 @@ void baseimg_init(void) {
LOG("baseimg", "looking for base image...\n");
for (size_t i = 0; i < BOOT_INFO.modules->module_count; i++) {
struct limine_file *module = BOOT_INFO.modules->modules[i];
if (hal_strcmp(util_get_filename(module->path), "base.img.6pk") == 0) {
if (strcmp(util_get_filename(module->path), "base.img.6pk") == 0) {
baseimg = module;
break;
}
@ -37,7 +38,7 @@ void baseimg_init(void) {
if (baseimg == NULL) {
ERR("baseimg", "base.img.6pk not found\n");
hal_hang();
cpu_hang();
} else {
LOG("baseimg", "base.img.6pk found\n");
LOG("baseimg", "addr = %p, size = %lu\n", baseimg->address, baseimg->size);
@ -54,7 +55,7 @@ void baseimg_init(void) {
BASEIMG_DECOMP_ADDR, BASEIMG_DECOMPRESSED);
if (res < 0) {
ERR("baseimg", "could not uncompress base.img.6pk\n");
hal_hang();
cpu_hang();
}
BASEIMG_DECOMP_SIZE = res;
kprintf("%p %zu\n", BASEIMG_DECOMP_ADDR, BASEIMG_DECOMP_SIZE);

2
kernel/bitmap/bitmap.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "bitmap.h"
#include "bitmap/bitmap.h"
#include "util/util.h"
#include "kprintf.h"

5
kernel/bitmap/bitmap.h
View File

@ -4,8 +4,7 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "hal/hal.h"
#include "vmm/vmm.h"
typedef struct {
uint8_t *map;
@ -17,7 +16,7 @@ typedef struct {
} BitMap;
#define BITMAP_BLOCKS_PER_BYTE 8
#define BITMAP_BLOCK_SIZE HAL_PAGE_SIZE
#define BITMAP_BLOCK_SIZE VMM_PAGE_SIZE
#define BITMAP_INVALID_BLOCK ((size_t)-1)
void *bitmap_toptr(BitMap *bm, size_t block);

10
kernel/bootinfo/bootinfo.c
View File

@ -1,8 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include <limine.h>
#include "bootinfo.h"
#include "hal/hal.h"
#include "bootinfo/bootinfo.h"
#include "cpu/hang.h"
BootInfo BOOT_INFO;
@ -26,7 +26,7 @@ DEFINE_REQ(module, MODULE);
void bootinfo_init(void) {
if (framebuffer_req.response == NULL || framebuffer_req.response->framebuffer_count < 1) {
hal_hang();
cpu_hang();
}
BOOT_INFO.fb = framebuffer_req.response->framebuffers[0];
@ -35,7 +35,7 @@ void bootinfo_init(void) {
struct limine_paging_mode_response *pagingres = paging_req.response;
if (pagingres->mode != LIMINE_PAGING_MODE_X86_64_4LVL) {
hal_hang();
cpu_hang();
}
struct limine_hhdm_response *hhdmres = hhdm_req.response;
@ -68,7 +68,7 @@ void bootinfo_init(void) {
}
}
if (BOOT_INFO.smp_bspindex == (uint64_t)-1) {
hal_hang();
cpu_hang();
}
struct limine_rsdp_response *rsdpres = rsdp_req.response;

6
kernel/hal/x86_64/gdt.c → kernel/cpu/gdt.c
View File

@ -1,8 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include "compiler/attr.h"
#include "hal/hal.h"
#include "gdt.h"
#include "cpu/gdt.h"
#include "std/string.h"
#define GDT_PRESENT 0x80
#define GDT_TSS 0x89
@ -43,7 +43,7 @@ void gdt_setentry(GdtEntry *ent, uint32_t base, uint32_t limit, uint8_t acc, uin
}
void gdt_init(void) {
hal_memset(&tss, 0, sizeof(tss));
memset(&tss, 0, sizeof(tss));
tss.iopb_off = sizeof(tss);
tss.rsp0 = (uint64_t)(kernelstack + sizeof(kernelstack));

9
kernel/hal/x86_64/gdt.h → kernel/cpu/gdt.h
View File

@ -1,5 +1,8 @@
#ifndef HAL_GDT_H_
#define HAL_GDT_H_
#ifndef CPU_GDT_H_
#define CPU_GDT_H_
#include <stdint.h>
#include "compiler/attr.h"
#define KCODE 0x08
#define KDATA 0x10
@ -23,4 +26,4 @@ ALIGNED(16) extern Tss tss;
void gdt_init(void);
#endif // HAL_GDT_H_
#endif // CPU_GDT_H_

10
kernel/cpu/hang.c Normal file
View File

@ -0,0 +1,10 @@
#include "cpu/hang.h"
#include "intr/intr.h"
void cpu_hang(void) {
intr_disable();
for(;;) {
asm("hlt");
}
}

6
kernel/cpu/hang.h Normal file
View File

@ -0,0 +1,6 @@
#ifndef CPU_HANG_H_
#define CPU_HANG_H_
void cpu_hang(void);
#endif // CPU_HANG_H_

0
kernel/hal/x86_64/regs.S → kernel/cpu/regs.S
View File

14
kernel/dev/dev.c
View File

@ -1,18 +1,18 @@
#include <stdint.h>
#include <stddef.h>
#include "spinlock/spinlock.h"
#include "dev.h"
#include "std/string.h"
#include "dev/dev.h"
#include "dev/termdev.h"
#include "dev/ps2kbdev.h"
#include "dev/serialdev.h"
#include "dev/fbdev.h"
#include "hshtb.h"
#include "hal/hal.h"
#include "termdev.h"
#include "ps2kbdev.h"
#include "serialdev.h"
#include "fbdev.h"
DevTable DEVTABLE;
void dev_init(void) {
hal_memset(&DEVTABLE, 0, sizeof(DEVTABLE));
memset(&DEVTABLE, 0, sizeof(DEVTABLE));
spinlock_init(&DEVTABLE.spinlock);
termdev_init();

10
kernel/dev/fbdev.c
View File

@ -1,14 +1,14 @@
#include <stdint.h>
#include <stddef.h>
#include "fbdev.h"
#include "dev.h"
#include "dev/fbdev.h"
#include "dev/dev.h"
#include "sysdefs/dev.h"
#include "hshtb.h"
#include "spinlock/spinlock.h"
#include "util/util.h"
#include "hal/hal.h"
#include "bootinfo/bootinfo.h"
#include "std/string.h"
#include "errors.h"
#include "hshtb.h"
int32_t fbdev_getinfo(struct Dev *dev, uint8_t *buffer, size_t len, uint64_t pid) {
(void)dev; (void)pid;
@ -24,7 +24,7 @@ int32_t fbdev_getinfo(struct Dev *dev, uint8_t *buffer, size_t len, uint64_t pid
.fontw = 8,
.fonth = 16,
};
hal_memcpy(buffer, &info, sizeof(info));
memcpy(buffer, &info, sizeof(info));
return E_OK;
}

12
kernel/dev/ps2kbdev.c
View File

@ -1,15 +1,15 @@
#include <stdint.h>
#include <stddef.h>
#include "kprintf.h"
#include "hal/hal.h"
#include "ps2kbdev.h"
#include "dev.h"
#include "errors.h"
#include "dev/ps2kbdev.h"
#include "dev/dev.h"
#include "dlmalloc/malloc.h"
#include "util/util.h"
#include "hshtb.h"
#include "sysdefs/dev.h"
#include "proc/proc.h"
#include "io/io.h"
#include "errors.h"
#include "hshtb.h"
#include "kprintf.h"
#define KB_CTL_STATUS 0x64
#define KB_DATA_IN_BUF 0x01

10
kernel/dev/serialdev.c
View File

@ -1,13 +1,13 @@
#include <stdint.h>
#include <stddef.h>
#include "dev.h"
#include "serialdev.h"
#include "errors.h"
#include "dev/dev.h"
#include "dev/serialdev.h"
#include "util/util.h"
#include "hshtb.h"
#include "sysdefs/dev.h"
#include "io/io.h"
#include "errors.h"
#include "hshtb.h"
#include "kprintf.h"
#include "hal/hal.h"
// https://wiki.osdev.org/Serial_Ports

11
kernel/dev/termdev.c
View File

@ -1,13 +1,12 @@
#include <stdint.h>
#include <stddef.h>
#include "kprintf.h"
#include "hal/hal.h"
#include "termdev.h"
#include "dev.h"
#include "errors.h"
#include "dev/termdev.h"
#include "dev/dev.h"
#include "util/util.h"
#include "hshtb.h"
#include "sysdefs/dev.h"
#include "kprintf.h"
#include "hshtb.h"
#include "errors.h"
int32_t termdev_putch(struct Dev *dev, uint8_t *buffer, size_t len, uint64_t pid) {
(void)dev; (void)pid;

2
kernel/diskpart/diskpart.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include "storedev/storedev.h"
#include "mbr.h"
#include "diskpart/mbr.h"
#include "util/util.h"
#include "kprintf.h"

12
kernel/diskpart/mbr.c
View File

@ -2,14 +2,14 @@
#include <stdint.h>
#include <stddef.h>
#include "storedev/storedev.h"
#include "mbr.h"
#include "diskpart.h"
#include "diskpart/mbr.h"
#include "diskpart/diskpart.h"
#include "compiler/attr.h"
#include "errors.h"
#include "kprintf.h"
#include "hal/hal.h"
#include "util/util.h"
#include "dev/dev.h"
#include "std/string.h"
#include "errors.h"
#include "kprintf.h"
typedef struct {
uint8_t driveattrs;
@ -62,7 +62,7 @@ bool diskpart_mbr_probe(StoreDev *sd) {
LOG("diskpart", "probing for MBR\n");
MBR mbr;
hal_memset(&mbr, 0, sizeof(mbr));
memset(&mbr, 0, sizeof(mbr));
sd->read(sd, (uint8_t *const)&mbr, 0, 0, sizeof(mbr));
if (!(mbr.validsign[0] == 0x55 && mbr.validsign[1] == 0xAA)) {

12
kernel/dlmalloc/dlmalloc_port.inc
View File

@ -1,14 +1,16 @@
// Config
#include <stddef.h>
#include "hal/hal.h"
#include "spinlock/spinlock.h"
#include "kprintf.h"
#include "bitmap/bitmap.h"
#include "util/util.h"
#include "pmm/pmm.h"
#include "malloc.h"
#include "dlmalloc/malloc.h"
#include "bootinfo/bootinfo.h"
#include "std/string.h"
#include "vmm/vmm.h"
#include "cpu/hang.h"
#include "kprintf.h"
#define USE_DL_PREFIX 1
#define LACKS_SYS_TYPES_H 1
@ -26,7 +28,7 @@
#define ABORT \
do { \
ERR("dlmalloc", "Aborting..."); \
hal_hang(); \
cpu_hang(); \
} while(0)
#define MALLOC_FAILURE_ACTION
#define HAVE_MORECORE 1
@ -67,7 +69,7 @@ void *sbrk(long inc) {
uint64_t blocks = _DIV_ROUNDUP(inc, BITMAP_BLOCK_SIZE);
uint8_t *virt = VIRT(pmm_alloc(blocks));
hal_memset(virt, 0, blocks * BITMAP_BLOCK_SIZE);
memset(virt, 0, blocks * BITMAP_BLOCK_SIZE);
_last = (void *)(virt + inc);
return virt;
}

8
kernel/fs/portlfs/portlfs.c
View File

@ -2,10 +2,10 @@
#include <stdbool.h>
#include "fs/littlefs/lfs.h"
#include "vfs/vfs.h"
#include "dlmalloc/malloc.h"
#include "std/string.h"
#include "errors.h"
#include "kprintf.h"
#include "dlmalloc/malloc.h"
#include "hal/hal.h"
int32_t littlefs_cleanup(struct VfsMountPoint *vmp) {
dlfree((void *)vmp->fs.littlefs.instance.cfg);
@ -132,7 +132,7 @@ struct VfsObj *littlefs_open(struct VfsMountPoint *vmp, const char *path, uint32
if (vobj == NULL) {
return NULL;
}
hal_memset(vobj, 0, sizeof(*vobj));
memset(vobj, 0, sizeof(*vobj));
spinlock_init(&vobj->spinlock);
int lfs_flags = 0;
@ -214,7 +214,7 @@ int32_t littlefs_fetchdirent(struct VfsMountPoint *vmp, const char *path, FsDire
direntbuf->stat.type = FSSTAT_DIR;
}
hal_memcpy(direntbuf->name, entinfo.name, sizeof(direntbuf->name));
memcpy(direntbuf->name, entinfo.name, sizeof(direntbuf->name));
break;
}
i++;

34
kernel/hal/hal.h
View File

@ -1,34 +0,0 @@
#ifndef KERNEL_HAL_HAL_H_
#define KERNEL_HAL_HAL_H_
#include <stdint.h>
#include <stddef.h>
__attribute__((noreturn)) void hal_hang(void);
void hal_init(void);
void hal_intr_disable(void);
void hal_intr_enable(void);
void *hal_memset(void *p, int c, size_t n);
void *hal_memcpy(void *dst, const void *src, size_t n);
size_t hal_strlen(char *s);
int hal_memcmp(const void *s1, const void *s2, int len);
int hal_strcmp(const char *a, const char *b);
size_t hal_strcspn(const char *s, const char *reject);
size_t hal_strspn(const char *s, const char *accept);
char *hal_strcpy(char *dest, const char *src);
char *hal_strchr(const char *s, int c);
char *hal_strstr(const char *str, const char *substring);
char *hal_string_combine(char *dest, const char *src);
void hal_wait(uint32_t ms);
int32_t hal_randnum(void);
#define HAL_PAGE_SIZE 0x1000
#include "x86_64/vmm.h"
#include "x86_64/switch.h"
#include "x86_64/paging.h"
#include "x86_64/intr.h"
#include "x86_64/io.h"
#include "x86_64/gdt.h"
#endif // KERNEL_HAL_HAL_H_

152
kernel/hal/util.c
View File

@ -1,152 +0,0 @@
#include <stdint.h>
#include <stddef.h>
#include "hal.h"
void *hal_memset(void *p, int c, size_t n) {
char *cp = p;
for (size_t i = 0; i < n; i++) cp[i] = c;
return p;
}
void *hal_memcpy(void *dst, const void *src, size_t n) {
char *a = dst;
const char *b = src;
for (size_t i = 0; i < n; i++) a[i] = b[i];
return dst;
}
size_t hal_strlen(char *s) {
char *s2;
for (s2 = s; *s2; ++s2);
return (s2 - s);
}
// https://aticleworld.com/memcmp-in-c/
int hal_memcmp(const void *s1, const void *s2, int len)
{
unsigned char *p = (unsigned char *)s1;
unsigned char *q = (unsigned char *)s2;
int charCompareStatus = 0;
//If both pointer pointing same memory block
if (s1 == s2)
{
return charCompareStatus;
}
while (len > 0)
{
if (*p != *q)
{ //compare the mismatching character
charCompareStatus = (*p >*q)?1:-1;
break;
}
len--;
p++;
q++;
}
return charCompareStatus;
}
int hal_strcmp(const char *a, const char *b) {
while (*a && (*a == *b)) {
a++, b++;
}
return (unsigned char)*a - (unsigned char)*b;
}
size_t hal_strcspn(const char *s, const char *reject) {
size_t count = 0;
for (; *s != '\0'; ++s) {
const char *r = reject;
while (*r != '\0') {
if (*s == *r) {
return count;
}
r++;
}
count++;
}
return count;
}
size_t hal_strspn(const char *s, const char *accept) {
size_t count = 0;
for (; *s != '\0'; ++s) {
const char *a = accept;
int matched = 0;
while (*a != '\0') {
if (*s == *a) {
matched = 1;
break;
}
a++;
}
if (!matched) {
return count;
}
count++;
}
return count;
}
char *hal_strcpy(char *dest, const char *src) {
char *d = dest;
while ((*d++ = *src++) != '\0') {
;
}
return dest;
}
char *hal_strchr(const char *s, int c) {
char ch = (char)c;
while (*s != '\0') {
if (*s == ch) {
return (char *)s;
}
s++;
}
if (ch == '\0') {
return (char *)s;
}
return NULL;
}
char *hal_strstr(const char *str, const char *substring)
{
const char *a;
const char *b;
b = substring;
if (*b == 0) {
return (char *) str;
}
for ( ; *str != 0; str += 1) {
if (*str != *b) {
continue;
}
a = str;
while (1) {
if (*b == 0) {
return (char *) str;
}
if (*a++ != *b++) {
break;
}
}
b = substring;
}
return NULL;
}
char *hal_string_combine(char *dest, const char *src) {
size_t i, j;
for(i = 0; dest[i] != '\0'; i++);
for(j = 0; src[j] != '\0'; j++) {
dest[i+j] = src[j];
}
dest[i+j] = '\0';
return dest;
}

27
kernel/hal/x86_64/hal.c
View File

@ -1,27 +0,0 @@
#include <stdint.h>
#include <stdbool.h>
#include "hal/hal.h"
#include "kprintf.h"
#include "gdt.h"
#include "intr.h"
#include "pic.h"
#include "pit.h"
void hal_init(void) {
gdt_init();
intr_init();
pic_init();
pit_init();
hal_intr_disable();
}
__attribute__((noreturn)) void hal_hang(void) {
for(;;) {
asm("hlt");
}
}
void hal_wait(uint32_t ms) {
pit_wait(ms);
}

4
kernel/hal/x86_64/paging.S
View File

@ -1,4 +0,0 @@
.global hal_loadpd
hal_loadpd:
mov %rdi, %cr3
retq

6
kernel/hal/x86_64/paging.h
View File

@ -1,6 +0,0 @@
#ifndef HAL_PAGING_H_
#define HAL_PAGING_H_
void hal_loadpd(PgTable *cr3);
#endif // HAL_PAGING_H_

22
kernel/hal/x86_64/pic.c
View File

@ -1,22 +0,0 @@
#include <stddef.h>
#include <stdint.h>
#include "pic.h"
#include "io.h"
#include "intr.h"
void pic_init(void) {
io_out8(PIC1_CMD, ICW1_INIT | ICW1_ICW4);
io_out8(PIC2_CMD, ICW1_INIT | ICW1_ICW4);
io_out8(PIC1_DATA, INTR_IRQBASE);
io_out8(PIC2_DATA, INTR_IRQBASE+8);
io_out8(PIC1_DATA, 2);
io_out8(PIC2_DATA, 2);
io_out8(PIC1_DATA, ICW4_8086);
io_out8(PIC2_DATA, ICW4_8086);
io_out8(PIC1_DATA, 0);
io_out8(PIC2_DATA, 0);
}

25
kernel/hal/x86_64/pic.h
View File

@ -1,25 +0,0 @@
#ifndef HAL_PIC_H_
#define HAL_PIC_H_
#define PIC1_CMD 0x0020
#define PIC1_DATA 0x0021
#define PIC2_CMD 0x00A0
#define PIC2_DATA 0x00A1
#define PIC_EOI 0x20
#define ICW1_ICW4 0x01
#define ICW1_SINGLE 0x02
#define ICW1_ADI 0x04
#define ICW1_LTIM 0x08
#define ICW1_INIT 0x10
#define ICW4_8086 0x01
#define ICW4_AUTO 0x02
#define ICW4_BUFSLAVE 0x04
#define ICW4_BUFMASTER 0x0C
#define ICW4_SFNM 0x10
void pic_init(void);
#endif // HAL_PIC_H_

11
kernel/hal/x86_64/pit.h
View File

@ -1,11 +0,0 @@
#ifndef HAL_PIT_H_
#define HAL_PIT_H_
#include <stdint.h>
extern volatile uint32_t PIT_TICKS;
void pit_init(void);
void pit_wait(uint32_t ms);
#endif // HAL_PIT_H_

6
kernel/hal/x86_64/switch.h
View File

@ -1,6 +0,0 @@
#ifndef HAL_SWITCH_H_
#define HAL_SWITCH_H_
extern void hal_switchproc(void *newsp, PgTable *cr3);
#endif // HAL_SWITCH_H_

128
kernel/hal/x86_64/vmm.c
View File

@ -1,128 +0,0 @@
#include <stddef.h>
#include <stdint.h>
#include "vmm.h"
#include "hal/hal.h"
#include "bootinfo/bootinfo.h"
#include "pmm/pmm.h"
#include "paging.h"
#include "proc/proc.h"
#include "kprintf.h"
#include "spinlock/spinlock.h"
uint64_t KERNEL_CR3 = 0;
SpinLock spinlock;
uint64_t hal_vmm_current_cr3(void) {
uint64_t cr3;
asm volatile("mov %%cr3, %0" : "=r"(cr3));
return cr3;
}
PgIndex hal_vmm_pageindex(uint64_t vaddr) {
PgIndex ret;
ret.pml4 = (vaddr >> 39) & 0x1ff;
ret.pml3 = (vaddr >> 30) & 0x1ff;
ret.pml2 = (vaddr >> 21) & 0x1ff;
ret.pml1 = (vaddr >> 12) & 0x1ff;
return ret;
}
uint64_t *hal_vmm_nexttable(uint64_t *table, uint64_t ent, bool alloc) {
uint64_t entry = table[ent];
uint64_t phys;
if (entry & HAL_PG_PRESENT) {
phys = entry & ~0xFFFULL;
} else {
if (!alloc) {
return NULL;
}
uint8_t *newphys = pmm_alloc(1);
phys = (uint64_t)newphys;
hal_memset(VIRT(phys), 0, HAL_PAGE_SIZE);
table[ent] = phys | HAL_PG_USER | HAL_PG_RW | HAL_PG_PRESENT;
}
return (uint64_t *)((uint8_t *)VIRT(phys));
}
void hal_vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags) {
uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
PgIndex pi = hal_vmm_pageindex(virtaddr);
uint64_t *pml3 = hal_vmm_nexttable(pml4, pi.pml4, true);
uint64_t *pml2 = hal_vmm_nexttable(pml3, pi.pml3, true);
uint64_t *pml1 = hal_vmm_nexttable(pml2, pi.pml2, true);
uint64_t *pte = &pml1[pi.pml1];
*pte = (physaddr & ~0xFFFULL) | ((uint64_t)flags & 0x7ULL);
}
void hal_vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr) {
uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
PgIndex pi = hal_vmm_pageindex(virtaddr);
uint64_t *pml3 = hal_vmm_nexttable(pml4, pi.pml4, false);
uint64_t *pml2 = hal_vmm_nexttable(pml3, pi.pml3, false);
uint64_t *pml1 = hal_vmm_nexttable(pml2, pi.pml2, false);
uint64_t *pte = &pml1[pi.pml1];
*pte &= ~HAL_PG_PRESENT;
}
void hal_vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags) {
if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PAGE_SIZE != 0) {
return;
}
spinlock_acquire(&spinlock);
uint8_t *vaddr = (uint8_t *)virtstart;
uint8_t *paddr = (uint8_t *)physstart;
uint8_t *end = (uint8_t *)virtstart + size;
for (; vaddr < end; vaddr += HAL_PAGE_SIZE, paddr += HAL_PAGE_SIZE) {
hal_vmm_map_page(cr3phys, (uint64_t)vaddr, (uint64_t)paddr, flags);
}
spinlock_release(&spinlock);
}
void hal_vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size) {
if (size % HAL_PAGE_SIZE != 0 || (uint64_t)virtstart % HAL_PAGE_SIZE != 0 || (uint64_t)physstart % HAL_PAGE_SIZE != 0) {
return;
}
spinlock_acquire(&spinlock);
uint8_t *vaddr = (uint8_t *)virtstart;
uint8_t *end = vaddr + size;
for (; vaddr < end; vaddr += HAL_PAGE_SIZE) {
hal_vmm_unmap_page(cr3phys, (uint64_t)vaddr);
}
spinlock_release(&spinlock);
}
void hal_vmm_map_kern(uint64_t targetcr3) {
uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
uint64_t *cr3 = (uint64_t *)VIRT(targetcr3);
for (size_t i = 0; i < 512; i++) {
cr3[i] = kcr3[i];
}
}
uint64_t hal_vmm_userproc_pml4_phys(void) {
uint8_t *cr3phys = pmm_alloc(1);
uint64_t phys = (uint64_t)cr3phys;
hal_memset(VIRT(phys), 0, HAL_PAGE_SIZE);
uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
uint64_t *pml4 = (uint64_t *)VIRT(phys);
for (size_t i = 256; i < 512; i++) {
pml4[i] = kcr3[i];
}
return phys;
}
void hal_vmm_init(void) {
spinlock_init(&spinlock);
KERNEL_CR3 = hal_vmm_current_cr3();
}

14
kernel/hshtb.h
View File

@ -4,8 +4,8 @@
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "hal/hal.h"
#include "util/util.h"
#include "std/string.h"
#define HSHTB_FNV32_OFF 0x811c9dc5u
#define HSHTB_FNV32_PRIME 0x01000193u
@ -32,7 +32,7 @@ enum {
#define HSHTB_ALLOC(tb, keyfield, k, out) \
do { \
size_t __len = __HSHTB_ARRAY_LEN(tb); \
uint32_t __h = hshtb_fnv32((k), hal_strlen((k))); \
uint32_t __h = hshtb_fnv32((k), strlen((k))); \
size_t __idx = __h % __len; \
size_t __start = __idx; \
typeof(&(tb)[0]) __tomb = NULL; \
@ -40,13 +40,13 @@ enum {
do { \
if ((tb)[__idx]._hshtbstate == HSHTB_EMPTY) { \
typeof(&(tb)[0]) __slot = __tomb ? __tomb : &(tb)[__idx]; \
hal_memset(__slot, 0, sizeof(*__slot)); \
memset(__slot, 0, sizeof(*__slot)); \
__slot->_hshtbstate = HSHTB_TAKEN; \
hal_memcpy(__slot->keyfield, (k), MIN(sizeof(__slot->keyfield) - 1, hal_strlen((k)))); \
memcpy(__slot->keyfield, (k), MIN(sizeof(__slot->keyfield) - 1, strlen((k)))); \
(out) = __slot; \
break; \
} \
if ((tb)[__idx]._hshtbstate == HSHTB_TAKEN && hal_strcmp((tb)[__idx].keyfield, (k)) == 0) { \
if ((tb)[__idx]._hshtbstate == HSHTB_TAKEN && strcmp((tb)[__idx].keyfield, (k)) == 0) { \
(out) = &(tb)[__idx]; \
break; \
} \
@ -60,7 +60,7 @@ enum {
#define HSHTB_GET(tb, keyfield, k, out) \
do { \
size_t __len = __HSHTB_ARRAY_LEN(tb); \
uint32_t __h = hshtb_fnv32((k), hal_strlen((k))); \
uint32_t __h = hshtb_fnv32((k), strlen((k))); \
size_t __idx = __h % __len; \
size_t __start = __idx; \
(out) = NULL; \
@ -68,7 +68,7 @@ enum {
if ((tb)[__idx]._hshtbstate == HSHTB_EMPTY) { \
break; \
} \
if ((tb)[__idx]._hshtbstate == HSHTB_TAKEN && hal_strcmp((tb)[__idx].keyfield, (k)) == 0) { \
if ((tb)[__idx]._hshtbstate == HSHTB_TAKEN && strcmp((tb)[__idx].keyfield, (k)) == 0) { \
(out) = &(tb)[__idx]; \
break; \
} \

40
kernel/hal/x86_64/intr.c → kernel/intr/intr.c
View File

@ -1,21 +1,21 @@
#include <stddef.h>
#include <stdint.h>
#include <stdbool.h>
#include "intr.h"
#include "io.h"
#include "gdt.h"
#include "hal/hal.h"
#include "kprintf.h"
#include "intr/intr.h"
#include "intr/pic.h"
#include "intr/pit.h"
#include "io/io.h"
#include "cpu/gdt.h"
#include "compiler/attr.h"
#include "pic.h"
#include "pit.h"
#include "proc/proc.h"
#include "syscall/syscall.h"
#include "errors.h"
#include "ipc/pipe/pipe.h"
#include "rbuf/rbuf.h"
#include "dlmalloc/malloc.h"
#include "util/util.h"
#include "cpu/hang.h"
#include "kprintf.h"
#include "errors.h"
typedef struct IntrHandler {
struct IntrHandler *next;
@ -45,11 +45,11 @@ void backtrace(BackTraceFrame *bt) {
}
}
void hal_intr_disable(void) {
void intr_disable(void) {
asm volatile("cli");
}
void hal_intr_enable(void) {
void intr_enable(void) {
asm volatile("sti");
}
@ -160,6 +160,9 @@ void intr_init(void) {
idt_setentry(0x80, (uint64_t)&intr_vec128, 0xEE);
idt_init();
intr_pic_init();
intr_pit_init();
intr_disable();
}
void intr_dumpframe(IntrStackFrame *frame) {
@ -185,7 +188,7 @@ void intr_dumpframe(IntrStackFrame *frame) {
);
}
void hal_syscalldispatch(IntrStackFrame *frame) {
void intr_syscalldispatch(IntrStackFrame *frame) {
uint64_t sysnum = frame->regs.rax;
if (sysnum < SYSCALLS_MAX) {
SyscallFn fn = SYSCALL_TABLE[sysnum];
@ -194,7 +197,7 @@ void hal_syscalldispatch(IntrStackFrame *frame) {
return;
}
uint64_t calling_proc_pid = PROCS.current->pid;
hal_intr_enable();
intr_enable();
int32_t ret = fn(frame, calling_proc_pid, frame->regs.rdi, frame->regs.rsi, frame->regs.rdx,
frame->regs.r10, frame->regs.r8, frame->regs.r9);
@ -205,11 +208,6 @@ void hal_syscalldispatch(IntrStackFrame *frame) {
}
}
void intr_eoi() {
io_out8(PIC2_CMD, PIC_EOI);
io_out8(PIC1_CMD, PIC_EOI);
}
void intr_handleintr(IntrStackFrame *frame) {
if (frame->trapnum <= 31) {
kprintf("ERROR %s, 0x%lX\n", exceptions[frame->trapnum], frame->errnum);
@ -221,13 +219,13 @@ void intr_handleintr(IntrStackFrame *frame) {
proc_sched((void *)frame);
} else {
kprintf("Kernel error :(\n");
hal_hang();
cpu_hang();
}
} else if (frame->trapnum >= 32 && frame->trapnum <= 47) {
switch (frame->trapnum) {
case INTR_IRQBASE+0:
PIT_TICKS++;
intr_eoi();
intr_pic_eoi();
proc_sched((void *)frame);
break;
default:
@ -237,11 +235,11 @@ void intr_handleintr(IntrStackFrame *frame) {
ih->fn();
}
}
intr_eoi();
intr_pic_eoi();
break;
}
} else if (frame->trapnum == 0x80) {
hal_syscalldispatch(frame);
intr_syscalldispatch(frame);
}
}

13
kernel/hal/x86_64/intr.h → kernel/intr/intr.h
View File

@ -1,10 +1,11 @@
#ifndef HAL_INTR_H_
#define HAL_INTR_H_
#ifndef INTR_INTR_H_
#define INTR_INTR_H_
#include <stdint.h>
#include "compiler/attr.h"
#define INTR_IRQBASE 0x20
#include "compiler/attr.h"
typedef struct {
uint64_t r15;
uint64_t r14;
@ -34,6 +35,8 @@ typedef struct {
} PACKED IntrStackFrame;
void intr_attchhandler(void (*fn)(void), int irq);
void intr_disable(void);
void intr_enable(void);
void intr_init(void);
#endif // HAL_INTR_H_
#endif // INTR_INTR_H_

2
kernel/hal/x86_64/intr0.S → kernel/intr/intr0.S
View File

@ -1,4 +1,4 @@
#include "regs.S"
#include "cpu/regs.S"
.extern intr_handleintr

46
kernel/intr/pic.c Normal file
View File

@ -0,0 +1,46 @@
#include <stddef.h>
#include <stdint.h>
#include "io/io.h"
#include "intr/pic.h"
#include "intr/intr.h"
#define PIC1_CMD 0x0020
#define PIC1_DATA 0x0021
#define PIC2_CMD 0x00A0
#define PIC2_DATA 0x00A1
#define PIC_EOI 0x20
#define ICW1_ICW4 0x01
#define ICW1_SINGLE 0x02
#define ICW1_ADI 0x04
#define ICW1_LTIM 0x08
#define ICW1_INIT 0x10
#define ICW4_8086 0x01
#define ICW4_AUTO 0x02
#define ICW4_BUFSLAVE 0x04
#define ICW4_BUFMASTER 0x0C
#define ICW4_SFNM 0x10
void intr_pic_init(void) {
io_out8(PIC1_CMD, ICW1_INIT | ICW1_ICW4);
io_out8(PIC2_CMD, ICW1_INIT | ICW1_ICW4);
io_out8(PIC1_DATA, INTR_IRQBASE);
io_out8(PIC2_DATA, INTR_IRQBASE+8);
io_out8(PIC1_DATA, 2);
io_out8(PIC2_DATA, 2);
io_out8(PIC1_DATA, ICW4_8086);
io_out8(PIC2_DATA, ICW4_8086);
io_out8(PIC1_DATA, 0);
io_out8(PIC2_DATA, 0);
}
void intr_pic_eoi(void) {
io_out8(PIC2_CMD, PIC_EOI);
io_out8(PIC1_CMD, PIC_EOI);
}

7
kernel/intr/pic.h Normal file
View File

@ -0,0 +1,7 @@
#ifndef INTR_PIC_H_
#define INTR_PIC_H_
void intr_pic_init(void);
void intr_pic_eoi(void);
#endif // INTR_PIC_H_

8
kernel/hal/x86_64/pit.c → kernel/intr/pit.c
View File

@ -1,6 +1,6 @@
#include <stdint.h>
#include "pit.h"
#include "io.h"
#include "intr/pit.h"
#include "io/io.h"
#define PIT_COUNTER0 0x40
#define PIT_CMD 0x43
@ -25,7 +25,7 @@
volatile uint32_t PIT_TICKS;
void pit_init(void) {
void intr_pit_init(void) {
uint32_t hz = 1000;
uint32_t div = PIT_FREQ / hz;
io_out8(PIT_CMD, PIT_CMD_BINARY | PIT_CMD_MODE3 | PIT_CMD_RW_BOTH | PIT_CMD_COUNTER0);
@ -33,7 +33,7 @@ void pit_init(void) {
io_out8(PIT_COUNTER0, div >> 8);
}
void pit_wait(uint32_t ms) {
void intr_pit_wait(uint32_t ms) {
uint32_t now = PIT_TICKS;
while (PIT_TICKS - now < ms);
}

11
kernel/intr/pit.h Normal file
View File

@ -0,0 +1,11 @@
#ifndef INTR_PIT_H_
#define INTR_PIT_H_
#include <stdint.h>
extern volatile uint32_t PIT_TICKS;
void intr_pit_init(void);
void intr_pit_wait(uint32_t ms);
#endif // INTR_PIT_H_

1
kernel/hal/x86_64/io.c → kernel/io/io.c
View File

@ -1,4 +1,5 @@
#include <stdint.h>
#include "io/io.h"
uint8_t io_in8(uint16_t port) {
uint8_t r;

6
kernel/hal/x86_64/io.h → kernel/io/io.h
View File

@ -1,5 +1,5 @@
#ifndef HAL_IO_H_
#define HAL_IO_H_
#ifndef IO_IO_H_
#define IO_IO_H_
#include <stdint.h>
@ -15,4 +15,4 @@ void io_out32(uint16_t port, uint32_t value);
void io_ins16(uint16_t port, void *addr, int cnt);
void io_outs16(uint16_t port, const void *addr, int cnt);
#endif // HAL_IO_H_
#endif // IO_IO_H_

8
kernel/ipc/pipe/pipe.c
View File

@ -2,14 +2,14 @@
#include <stddef.h>
#include "rbuf/rbuf.h"
#include "spinlock/spinlock.h"
#include "hal/hal.h"
#include "dlmalloc/malloc.h"
#include "errors.h"
#include "pipe.h"
#include "ipc/pipe/pipe.h"
#include "std/string.h"
#include "kprintf.h"
#include "errors.h"
int32_t ipc_pipeinit(IpcPipe *pipe, uint64_t pid) {
hal_memset(pipe, 0, sizeof(*pipe));
memset(pipe, 0, sizeof(*pipe));
spinlock_init(&pipe->spinlock);
pipe->ownerpid = pid;

11
kernel/kmain.c
View File

@ -1,7 +1,6 @@
#include <limine.h>
#include "kprintf.h"
#include "banner.h"
#include "hal/hal.h"
#include "bootinfo/bootinfo.h"
#include "pmm/pmm.h"
#include "term/term.h"
@ -15,6 +14,9 @@
#include "randcrypto/randcrypto.h"
#include "time/time.h"
#include "diskpart/diskpart.h"
#include "vmm/vmm.h"
#include "cpu/hang.h"
#include "cpu/gdt.h"
void log_bootinfo(void) {
char buf[100];
@ -34,16 +36,17 @@ static volatile LIMINE_BASE_REVISION(2);
void kmain(void) {
if (LIMINE_BASE_REVISION_SUPPORTED == false) {
hal_hang();
cpu_hang();
}
bootinfo_init();
term_init(BOOT_INFO.fb->address);
log_bootinfo();
log_time();
hal_init();
gdt_init();
intr_init();
pmm_init();
hal_vmm_init();
vmm_init();
randcrypto_init();
dev_init();
storedev_init();

6
kernel/path/path.c
View File

@ -1,5 +1,5 @@
#include "path.h"
#include "hal/hal.h"
#include "std/string.h"
void path_parse(const char *in, char *mp, char *path) {
if (in == 0 || *in == 0) {
@ -45,8 +45,8 @@ void path_parse(const char *in, char *mp, char *path) {
return;
}
if (hal_strstr(path, "/../") || hal_strstr(path, "/./")
|| hal_strcmp(path, "..") == 0 || hal_strcmp(path, ".") == 0) {
if (strstr(path, "/../") || strstr(path, "/./")
|| strcmp(path, "..") == 0 || strcmp(path, ".") == 0) {
mp[0] = 0;
path[0] = 0;
return;

11
kernel/pmm/pmm.c
View File

@ -1,12 +1,13 @@
#include <stddef.h>
#include <limine.h>
#include "pmm.h"
#include "kprintf.h"
#include "pmm/pmm.h"
#include "bitmap/bitmap.h"
#include "bootinfo/bootinfo.h"
#include "spinlock/spinlock.h"
#include "util/util.h"
#include "hal/hal.h"
#include "std/string.h"
#include "cpu/hang.h"
#include "kprintf.h"
PhysMem PHYS_MEM;
@ -31,13 +32,13 @@ void pmm_init(void) {
if (!memmap_ent) {
ERR("pmm", "required memory: {%lx}\n", bm->nbytes);
hal_hang();
cpu_hang();
}
size_t physbegin = memmap_ent->base;
bm->map = (uint8_t *)(physbegin + BOOT_INFO.hhdm_off);
hal_memset(bm->map, 0xff, bm->nbytes);
memset(bm->map, 0xff, bm->nbytes);
for (size_t i = 0; i < BOOT_INFO.memmap_entrycount; i++) {
struct limine_memmap_entry *entry = BOOT_INFO.memmap_entries[i];
if (entry == memmap_ent) {

54
kernel/proc/proc.c
View File

@ -1,21 +1,25 @@
#include <stdint.h>
#include <stdlib.h>
#include <stdbool.h>
#include "hal/hal.h"
#include "spinlock/spinlock.h"
#include "proc.h"
#include "proc/proc.h"
#include "dlmalloc/malloc.h"
#include "pmm/pmm.h"
#include "util/util.h"
#include "kprintf.h"
#include "elf.h"
#include "errors.h"
#include "vfs/vfs.h"
#include "bootinfo/bootinfo.h"
#include "ipc/pipe/pipe.h"
#include "sysdefs/proc.h"
#include "sysdefs/fs.h"
#include "time/time.h"
#include "std/string.h"
#include "cpu/gdt.h"
#include "intr/intr.h"
#include "switch.h"
#include "vmm/vmm.h"
#include "elf.h"
#include "errors.h"
#include "kprintf.h"
#define PROC_REAPER_FREQ 30
@ -47,25 +51,25 @@ ElfAuxval proc_load_elf_segs(Proc *proc, uint8_t *data) {
aux.phdr = (uint64_t)phdr->p_vaddr;
} break;
case PT_LOAD: {
uint64_t off = phdr->p_vaddr & (HAL_PAGE_SIZE - 1);
uint64_t blocks = (off + phdr->p_memsz + HAL_PAGE_SIZE - 1) / HAL_PAGE_SIZE;
uint64_t off = phdr->p_vaddr & (VMM_PAGE_SIZE - 1);
uint64_t blocks = (off + phdr->p_memsz + VMM_PAGE_SIZE - 1) / VMM_PAGE_SIZE;
uint8_t *physaddr = pmm_alloc(blocks);
uint8_t *virtaddr = (uint8_t *)(phdr->p_vaddr & ~(HAL_PAGE_SIZE - 1));
uint8_t *virtaddr = (uint8_t *)(phdr->p_vaddr & ~(VMM_PAGE_SIZE - 1));
hal_memset(VIRT(physaddr), 0, blocks * HAL_PAGE_SIZE);
hal_memcpy(VIRT(physaddr) + off, (data + phdr->p_offset), phdr->p_filesz);
memset(VIRT(physaddr), 0, blocks * VMM_PAGE_SIZE);
memcpy(VIRT(physaddr) + off, (data + phdr->p_offset), phdr->p_filesz);
uint32_t pgflags = HAL_PG_USER | HAL_PG_PRESENT;
uint32_t pgflags = VMM_PG_USER | VMM_PG_PRESENT;
if (phdr->p_flags & PF_W) {
pgflags |= HAL_PG_RW;
pgflags |= VMM_PG_RW;
}
hal_vmm_map_range(proc->platformdata.cr3, virtaddr, physaddr, blocks * HAL_PAGE_SIZE, pgflags);
vmm_map_range(proc->platformdata.cr3, virtaddr, physaddr, blocks * VMM_PAGE_SIZE, pgflags);
VasRange *range = dlmalloc(sizeof(*range));
range->virtstart = virtaddr;
range->physstart = physaddr;
range->size = blocks * HAL_PAGE_SIZE;
range->size = blocks * VMM_PAGE_SIZE;
range->pgflags = pgflags;
LL_APPEND(proc->vas, range);
@ -105,11 +109,11 @@ Proc *proc_spawnuser(char *mountpoint, char *path) {
vfs_close(vobj);
Proc *proc = dlmalloc(sizeof(*proc));
hal_memset(proc, 0, sizeof(*proc));
memset(proc, 0, sizeof(*proc));
ksprintf(proc->name, "%s:%s", mountpoint, path);
hal_memset(&proc->platformdata.trapframe, 0, sizeof(proc->platformdata.trapframe));
proc->platformdata.cr3 = hal_vmm_userproc_pml4_phys();
memset(&proc->platformdata.trapframe, 0, sizeof(proc->platformdata.trapframe));
proc->platformdata.cr3 = vmm_userproc_pml4_phys();
uint8_t *kstackp = (uint8_t *)pmm_alloc(PROC_STACKBLOCKS) + PROC_STACKSIZE;
proc->platformdata.kstack = kstackp;
@ -119,8 +123,8 @@ Proc *proc_spawnuser(char *mountpoint, char *path) {
uint64_t virttop = PROC_USER_STACK_TOP;
uint64_t virtbase = virttop - PROC_STACKSIZE;
uint32_t flags = HAL_PG_RW | HAL_PG_PRESENT | HAL_PG_USER;
hal_vmm_map_range(proc->platformdata.cr3, (void *)virtbase, (void *)pstackp, PROC_STACKSIZE, flags);
uint32_t flags = VMM_PG_RW | VMM_PG_PRESENT | VMM_PG_USER;
vmm_map_range(proc->platformdata.cr3, (void *)virtbase, (void *)pstackp, PROC_STACKSIZE, flags);
VasRange *range = dlmalloc(sizeof(*range));
range->virtstart = (uint8_t *)virtbase;
@ -202,8 +206,8 @@ void proc_reaper(void) {
VasRange *vas, *vastmp;
LL_FOREACH_SAFE(zombie->vas, vas, vastmp) {
hal_vmm_unmap_range(zombie->platformdata.cr3, vas->virtstart, vas->physstart, vas->size);
pmm_free((uintptr_t)vas->physstart, vas->size / HAL_PAGE_SIZE);
vmm_unmap_range(zombie->platformdata.cr3, vas->virtstart, vas->physstart, vas->size);
pmm_free((uintptr_t)vas->physstart, vas->size / VMM_PAGE_SIZE);
dlfree(vas);
}
@ -220,10 +224,10 @@ void proc_reaper(void) {
}
void proc_sched(void *cpustate) {
hal_intr_disable();
intr_disable();
sched_ticks++;
hal_memcpy(&PROCS.current->platformdata.trapframe, cpustate, sizeof(IntrStackFrame));
memcpy(&PROCS.current->platformdata.trapframe, cpustate, sizeof(IntrStackFrame));
PROCS.current = proc_nextready();
@ -232,7 +236,7 @@ void proc_sched(void *cpustate) {
}
tss.rsp0 = (uint64_t)VIRT(PROCS.current->platformdata.kstack);
hal_switchproc(&PROCS.current->platformdata.trapframe, (void *)PROCS.current->platformdata.cr3);
proc_switch(&PROCS.current->platformdata.trapframe, (void *)PROCS.current->platformdata.cr3);
}
void proc_kill(Proc *proc) {
@ -258,5 +262,5 @@ void proc_init(void) {
init->state = PROC_READY;
tss.rsp0 = (uint64_t)VIRT(PROCS.current->platformdata.kstack);
hal_switchproc(&PROCS.current->platformdata.trapframe, (void *)PROCS.current->platformdata.cr3);
proc_switch(&PROCS.current->platformdata.trapframe, (void *)PROCS.current->platformdata.cr3);
}

6
kernel/proc/proc.h
View File

@ -2,7 +2,6 @@
#define PROC_PROC_H_
#include <stdint.h>
#include "hal/hal.h"
#include "spinlock/spinlock.h"
#include "bitmap/bitmap.h"
#include "vfs/vfs.h"
@ -10,6 +9,9 @@
#include "sysdefs/proc.h"
#include "sysdefs/time.h"
#include "dev/dev.h"
#include "std/string.h"
#include "intr/intr.h"
#include "vmm/vmm.h"
#define PROC_NAME_MAX 0x100
@ -90,7 +92,7 @@ void proc_kill(Proc *proc);
#define PROC_ARG(proc, str) \
do { \
ProcArg *__arg = dlmalloc(sizeof(*__arg)); \
hal_strcpy(__arg->string, (str)); \
strcpy(__arg->string, (str)); \
LL_APPEND((proc)->procargs.list, __arg); \
(proc)->procargs.len++; \
} while(0)

6
kernel/hal/x86_64/switch.S → kernel/proc/switch.S
View File

@ -1,7 +1,7 @@
#include "regs.S"
#include "cpu/regs.S"
.global hal_switchproc
hal_switchproc:
.global proc_switch
proc_switch:
testq %rsi, %rsi
je 1f
movq %rsi, %cr3

8
kernel/proc/switch.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef PROC_SWITCH_H_
#define PROC_SWITCH_H_
#include "vmm/vmm.h"
extern void proc_switch(void *newsp, PgTable *cr3);
#endif // PROC_SWITCH_H_

4
kernel/hal/x86_64/randnum.S → kernel/randcrypto/physrand.S
View File

@ -1,5 +1,5 @@
.global hal_randnum
hal_randnum:
.global randcrypto_get_physrand
randcrypto_get_physrand:
mov $100, %ecx
xor %eax, %eax

8
kernel/randcrypto/physrand.h Normal file
View File

@ -0,0 +1,8 @@
#ifndef RANDCRYPTO_PHYSDRAND_H_
#define RANDCRYPTO_PHYSDRAND_H_
#include <stdint.h>
int32_t randcrypto_get_physrand(void);
#endif // RANDCRYPTO_PHYSDRAND_H_

4
kernel/randcrypto/randcrypto.c
View File

@ -1,5 +1,5 @@
#include "randcrypto.h"
#include "uniqid.h"
#include "randcrypto/randcrypto.h"
#include "randcrypto/uniqid.h"
void randcrypto_init(void) {
randcrypto_uniqid_init();

9
kernel/randcrypto/uniqid.c
View File

@ -1,9 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include "uniqid.h"
#include "atomic.h"
#include "randcrypto/uniqid.h"
#include "randcrypto/physrand.h"
#include "spinlock/spinlock.h"
#include "hal/hal.h"
static const char *base62 = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
@ -28,7 +27,7 @@ void uniqseed(void) {
return;
uint32_t seed = 0;
int32_t r = hal_randnum();
int32_t r = randcrypto_get_physrand();
if (r != -1) {
seed = (uint32_t)r;
} else {
@ -48,7 +47,7 @@ void randcrypto_gen_uniqid(char *out, size_t n) {
uniqseed();
int32_t r = hal_randnum();
int32_t r = randcrypto_get_physrand();
uint32_t extra = (r != -1) ? (uint32_t)r : uniqstate * 0x27d4eb2dU;
uniqstate += 0x9E3779B1u;

3
kernel/rbuf/rbuf.c
View File

@ -1,9 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "rbuf.h"
#include "rbuf/rbuf.h"
#include "kprintf.h"
#include "hal/hal.h"
void rbuf_init(RBuf *rbuf, uint8_t *buf, size_t bufsize) {
rbuf->buffer = buf;

3
kernel/spinlock/spinlock.c
View File

@ -1,8 +1,7 @@
#include <stdatomic.h>
#include <stdint.h>
#include <stdbool.h>
#include "spinlock.h"
#include "hal/hal.h"
#include "spinlock/spinlock.h"
#include "kprintf.h"
#define SPINLOCK_HINT() asm volatile("pause")

1
kernel/std/stdlib.c
View File

@ -1,6 +1,5 @@
#include <stdlib.h>
#include "dlmalloc/malloc.h"
#include "hal/hal.h"
void *malloc(size_t size) {
return dlmalloc(size);

136
kernel/std/string.c
View File

@ -1,39 +1,151 @@
#include <stddef.h>
#include "hal/hal.h"
#include <stdint.h>
void *memset(void *p, int c, size_t n) {
return hal_memset(p,c,n);
char *cp = p;
for (size_t i = 0; i < n; i++) cp[i] = c;
return p;
}
void *memcpy(void *dst, const void *src, size_t n) {
return hal_memcpy(dst,src,n);
char *a = dst;
const char *b = src;
for (size_t i = 0; i < n; i++) a[i] = b[i];
return dst;
}
size_t strlen(char *s) {
return hal_strlen(s);
char *s2;
for (s2 = s; *s2; ++s2);
return (s2 - s);
}
// https://aticleworld.com/memcmp-in-c/
int memcmp(const void *s1, const void *s2, int len)
{
unsigned char *p = (unsigned char *)s1;
unsigned char *q = (unsigned char *)s2;
int charCompareStatus = 0;
//If both pointer pointing same memory block
if (s1 == s2)
{
return charCompareStatus;
}
while (len > 0)
{
if (*p != *q)
{ //compare the mismatching character
charCompareStatus = (*p >*q)?1:-1;
break;
}
len--;
p++;
q++;
}
return charCompareStatus;
}
int strcmp(const char *a, const char *b) {
return hal_strcmp(a, b);
while (*a && (*a == *b)) {
a++, b++;
}
return (unsigned char)*a - (unsigned char)*b;
}
size_t strcspn(const char *s, const char *reject) {
return hal_strcspn(s, reject);
size_t count = 0;
for (; *s != '\0'; ++s) {
const char *r = reject;
while (*r != '\0') {
if (*s == *r) {
return count;
}
r++;
}
count++;
}
return count;
}
size_t strspn(const char *s, const char *accept) {
return hal_strspn(s, accept);
size_t count = 0;
for (; *s != '\0'; ++s) {
const char *a = accept;
int matched = 0;
while (*a != '\0') {
if (*s == *a) {
matched = 1;
break;
}
a++;
}
if (!matched) {
return count;
}
count++;
}
return count;
}
char *strcpy(char *dest, const char *src) {
return hal_strcpy(dest, src);
char *d = dest;
while ((*d++ = *src++) != '\0') {
;
}
return dest;
}
char *strchr(const char *s, int c) {
return hal_strchr(s, c);
char ch = (char)c;
while (*s != '\0') {
if (*s == ch) {
return (char *)s;
}
s++;
}
if (ch == '\0') {
return (char *)s;
}
return NULL;
}
int memcmp(const void *s1, const void *s2, int len) {
return hal_memcmp(s1, s2, len);
char *strstr(const char *str, const char *substring)
{
const char *a;
const char *b;
b = substring;
if (*b == 0) {
return (char *) str;
}
for ( ; *str != 0; str += 1) {
if (*str != *b) {
continue;
}
a = str;
while (1) {
if (*b == 0) {
return (char *) str;
}
if (*a++ != *b++) {
break;
}
}
b = substring;
}
return NULL;
}
char *strcat(char *dest, const char *src) {
size_t i, j;
for(i = 0; dest[i] != '\0'; i++);
for(j = 0; src[j] != '\0'; j++) {
dest[i+j] = src[j];
}
dest[i+j] = '\0';
return dest;
}

2
kernel/std/string.h
View File

@ -12,5 +12,7 @@ size_t strspn(const char *s, const char *accept);
char *strcpy(char *dest, const char *src);
char *strchr(const char *s, int c);
int memcmp(const void *s1, const void *s2, int len);
char *strstr(const char *str, const char *substring);
char *strcat(char *dest, const char *src);
#endif // STD_STRING_H_

8
kernel/storedev/atasd.c
View File

@ -1,14 +1,14 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "atasd.h"
#include "storedev.h"
#include "hal/hal.h"
#include "storedev/atasd.h"
#include "storedev/storedev.h"
#include "util/util.h"
#include "vfs/vfs.h"
#include "io/io.h"
#include "kprintf.h"
#include "errors.h"
#include "hshtb.h"
#include "vfs/vfs.h"
#define ATA_REG_DATA 0x00
#define ATA_REG_ERROR 0x01

4
kernel/storedev/partsd.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include "partsd.h"
#include "storedev.h"
#include "storedev/partsd.h"
#include "storedev/storedev.h"
#include "errors.h"
#include "kprintf.h"

12
kernel/storedev/ramsd.c
View File

@ -1,13 +1,13 @@
#include <stddef.h>
#include <stdint.h>
#include "spinlock/spinlock.h"
#include "errors.h"
#include "dlmalloc/malloc.h"
#include "ramsd.h"
#include "storedev.h"
#include "hal/hal.h"
#include "storedev/ramsd.h"
#include "storedev/storedev.h"
#include "util/util.h"
#include "std/string.h"
#include "kprintf.h"
#include "errors.h"
int32_t ramsd_init(struct StoreDev *sd, void *extra) {
RamSdInitExtra *e = extra;
@ -26,7 +26,7 @@ int32_t ramsd_init(struct StoreDev *sd, void *extra) {
int32_t ramsd_read(struct StoreDev *sd, uint8_t *const buffer, ptrdiff_t sector, ptrdiff_t off, size_t size) {
RamSd *ramsd = &sd->sd.ramsd;
spinlock_acquire(&sd->spinlock);
hal_memcpy(buffer, ramsd->buffer + (sector * sd->sectorsize + off), size);
memcpy(buffer, ramsd->buffer + (sector * sd->sectorsize + off), size);
spinlock_release(&sd->spinlock);
return E_OK;
}
@ -34,7 +34,7 @@ int32_t ramsd_read(struct StoreDev *sd, uint8_t *const buffer, ptrdiff_t sector,
int32_t ramsd_write(struct StoreDev *sd, const uint8_t *const buffer, ptrdiff_t sector, ptrdiff_t off, size_t size) {
RamSd *ramsd = &sd->sd.ramsd;
spinlock_acquire(&sd->spinlock);
hal_memcpy(ramsd->buffer + (sector * sd->sectorsize + off), buffer, size);
memcpy(ramsd->buffer + (sector * sd->sectorsize + off), buffer, size);
spinlock_release(&sd->spinlock);
return E_OK;
}

12
kernel/storedev/storedev.c
View File

@ -2,17 +2,17 @@
#include <stddef.h>
#include "storedev.h"
#include "spinlock/spinlock.h"
#include "kprintf.h"
#include "errors.h"
#include "dlmalloc/malloc.h"
#include "ramsd.h"
#include "atasd.h"
#include "storedev/ramsd.h"
#include "storedev/atasd.h"
#include "storedev/partsd.h"
#include "util/util.h"
#include "dev/dev.h"
#include "hshtb.h"
#include "hal/hal.h"
#include "randcrypto/uniqid.h"
#include "sysdefs/dev.h"
#include "kprintf.h"
#include "hshtb.h"
#include "errors.h"
StoreDevList STOREDEV_LIST;

6
kernel/storedev/storedev.h
View File

@ -4,9 +4,9 @@
#include <stdint.h>
#include <stddef.h>
#include "spinlock/spinlock.h"
#include "ramsd.h"
#include "atasd.h"
#include "partsd.h"
#include "storedev/ramsd.h"
#include "storedev/atasd.h"
#include "storedev/partsd.h"
#include "compiler/attr.h"
#include "dev/dev.h"

11
kernel/syscall/dev.c
View File

@ -1,14 +1,15 @@
#include <stdint.h>
#include <stddef.h>
#include "kprintf.h"
#include "syscall.h"
#include "errors.h"
#include "syscall/syscall.h"
#include "spinlock/spinlock.h"
#include "proc/proc.h"
#include "sysdefs/dev.h"
#include "util/util.h"
#include "hshtb.h"
#include "dev/dev.h"
#include "std/string.h"
#include "errors.h"
#include "kprintf.h"
#include "hshtb.h"
int32_t SYSCALL2(sys_dev_gethandle, dev1, devname1) {
uint64_t *devh = (uint64_t *)dev1;
@ -87,7 +88,7 @@ int32_t SYSCALL2(sys_dev_stat, devstat1, idx1) {
for (size_t i = 0; i < LEN(DEVTABLE.devs); i++) {
if (i == idx && DEVTABLE.devs[i]._hshtbstate == HSHTB_TAKEN) {
Dev *dev = &DEVTABLE.devs[i];
hal_memcpy(devstat->name, dev->ident, sizeof(dev->ident));
memcpy(devstat->name, dev->ident, sizeof(dev->ident));
for (size_t j = 0; j < DEV_FNS_MAX; j++) {
if (dev->fns[j] != NULL) {
devstat->nfns++;

2
kernel/syscall/dev.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "syscall/syscall.h"
int32_t SYSCALL2(sys_dev_gethandle, dev1, devname1);
int32_t SYSCALL0(sys_dev_listsize);

6
kernel/syscall/fs.c
View File

@ -1,14 +1,14 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "syscall/syscall.h"
#include "sysdefs/fs.h"
#include "errors.h"
#include "path/path.h"
#include "vfs/vfs.h"
#include "kprintf.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "util/util.h"
#include "errors.h"
#include "kprintf.h"
#define _MP_MAX 0xff
#define _PATH_MAX VFS_PATH_MAX

2
kernel/syscall/fs.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "syscall/syscall.h"
int32_t SYSCALL2(sys_fs_openf, opath1, oflags1);
int32_t SYSCALL1(sys_fs_closef, fsh1);

4
kernel/syscall/ipcpipe.c
View File

@ -1,12 +1,12 @@
#include <stddef.h>
#include <stdint.h>
#include "ipcpipe.h"
#include "syscall/ipcpipe.h"
#include "ipc/pipe/pipe.h"
#include "dlmalloc/malloc.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "errors.h"
#include "util/util.h"
#include "errors.h"
#include "kprintf.h"
int32_t SYSCALL4(sys_ipc_piperead, pid1, pipenum1, buffer1, len1) {

4
kernel/syscall/ipcpipe.h
View File

@ -1,7 +1,9 @@
#ifndef SYSCALL_IPCPIPE_H_
#define SYSCALL_IPCPIPE_H_
#include "syscall.h"
#include <stdint.h>
#include <stddef.h>
#include "syscall/syscall.h"
int32_t SYSCALL4(sys_ipc_piperead, pid1, pipenum1, buffer1, len1);
int32_t SYSCALL4(sys_ipc_pipewrite, pid1, pipenum1, buffer1, len1);

31
kernel/syscall/mman.c
View File

@ -1,15 +1,16 @@
#include <stdint.h>
#include "syscall.h"
#include "mman.h"
#include "syscall/syscall.h"
#include "syscall/mman.h"
#include "spinlock/spinlock.h"
#include "proc/proc.h"
#include "hal/hal.h"
#include "pmm/pmm.h"
#include "util/util.h"
#include "errors.h"
#include "sysdefs/mman.h"
#include "bootinfo/bootinfo.h"
#include "dlmalloc/malloc.h"
#include "std/string.h"
#include "vmm/vmm.h"
#include "errors.h"
#include "kprintf.h"
int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
@ -19,16 +20,16 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
uint64_t flags = flags1;
uint8_t **out = (uint8_t **)out1;
if (size == 0 || (size % HAL_PAGE_SIZE != 0)) {
if (size == 0 || (size % VMM_PAGE_SIZE != 0)) {
if (out != NULL) {
*out = NULL;
}
return E_INVALIDARGUMENT;
}
size_t pages = _DIV_ROUNDUP(size, HAL_PAGE_SIZE);
size_t pages = _DIV_ROUNDUP(size, VMM_PAGE_SIZE);
uint8_t *phys = (uint8_t *)pmm_alloc(pages);
hal_memset(VIRT(phys), 0, pages * HAL_PAGE_SIZE);
memset(VIRT(phys), 0, pages * VMM_PAGE_SIZE);
spinlock_acquire(&PROCS.spinlock);
Proc *proc = NULL;
@ -37,7 +38,7 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
uint8_t *virt = NULL;
if ((flags & MMAN_MAP_F_FIXED) && addr != NULL) {
if ((uintptr_t)addr % HAL_PAGE_SIZE != 0) {
if ((uintptr_t)addr % VMM_PAGE_SIZE != 0) {
if (out != NULL) {
*out = NULL;
}
@ -48,19 +49,19 @@ int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1) {
virt = addr;
} else {
virt = (uint8_t *)proc->mman_map_base;
proc->mman_map_base += pages * HAL_PAGE_SIZE;
proc->mman_map_base += pages * VMM_PAGE_SIZE;
}
uint64_t pflags = HAL_PG_USER | HAL_PG_PRESENT;
uint64_t pflags = VMM_PG_USER | VMM_PG_PRESENT;
if (prot & MMAN_MAP_PF_RW) {
pflags |= HAL_PG_RW;
pflags |= VMM_PG_RW;
}
hal_vmm_map_range(proc->platformdata.cr3, virt, phys, pages * HAL_PAGE_SIZE, pflags);
vmm_map_range(proc->platformdata.cr3, virt, phys, pages * VMM_PAGE_SIZE, pflags);
VasRange *range = dlmalloc(sizeof(*range));
range->virtstart = virt;
range->physstart = phys;
range->size = pages * HAL_PAGE_SIZE;
range->size = pages * VMM_PAGE_SIZE;
range->pgflags = pflags;
LL_APPEND(proc->vas, range);
@ -97,9 +98,9 @@ int32_t SYSCALL1(sys_mman_unmap, addr1) {
return E_INVALIDARGUMENT;
}
hal_vmm_unmap_range(proc->platformdata.cr3, tofree->virtstart, tofree->physstart, tofree->size);
vmm_unmap_range(proc->platformdata.cr3, tofree->virtstart, tofree->physstart, tofree->size);
LL_REMOVE(proc->vas, tofree);
pmm_free((uintptr_t)tofree->physstart, tofree->size / HAL_PAGE_SIZE);
pmm_free((uintptr_t)tofree->physstart, tofree->size / VMM_PAGE_SIZE);
dlfree(tofree);
return E_OK;
}

4
kernel/syscall/mman.h
View File

@ -1,7 +1,9 @@
#ifndef SYSCALL_MMAN_H_
#define SYSCALL_MMAN_H_
#include "syscall.h"
#include <stdint.h>
#include <stddef.h>
#include "syscall/syscall.h"
int32_t SYSCALL5(sys_mman_map, addr1, size1, prot1, flags1, out1);
int32_t SYSCALL1(sys_mman_unmap, addr1);

13
kernel/syscall/proc.c
View File

@ -1,16 +1,17 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "syscall/syscall.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "errors.h"
#include "util/util.h"
#include "sysdefs/proc.h"
#include "vfs/vfs.h"
#include "path/path.h"
#include "kprintf.h"
#include "dlmalloc/malloc.h"
#include "ipc/pipe/pipe.h"
#include "std/string.h"
#include "errors.h"
#include "kprintf.h"
#define _MP_MAX 0xff
#define _PATH_MAX VFS_PATH_MAX
@ -178,7 +179,7 @@ int32_t SYSCALL4(sys_proc_argv, pid1, argslen1, argbuf1, maxargs1) {
ret = E_INVALIDARGUMENT;
goto done;
}
hal_strcpy(argbuf[i], arg->string);
strcpy(argbuf[i], arg->string);
}
*argslen = i;
@ -214,7 +215,7 @@ int32_t SYSCALL2(sys_proc_stat, pidx, pstat1) {
LL_FOREACH_SAFE_IDX(PROCS.procs, p, ptmp, i) {
if (i == pidx) {
stat->pid = p->pid;
hal_strcpy(stat->name, p->name);
strcpy(stat->name, p->name);
stat->state = p->state;
VasRange *vas, *vastmp;
@ -222,7 +223,7 @@ int32_t SYSCALL2(sys_proc_stat, pidx, pstat1) {
stat->usemem += vas->size;
}
hal_memcpy(&stat->time, &p->time, sizeof(p->time));
memcpy(&stat->time, &p->time, sizeof(p->time));
break;
}
}

2
kernel/syscall/proc.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "syscall/syscall.h"
int32_t SYSCALL1(sys_proc_kill, pid1);
int32_t SYSCALL3(sys_proc_spawn, opath1, args1, argslen1);

6
kernel/syscall/randcrypto.c
View File

@ -1,8 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include "hal/hal.h"
#include "syscall.h"
#include "syscall/syscall.h"
#include "randcrypto/physrand.h"
int32_t SYSCALL0(sys_rand) {
return hal_randnum();
return randcrypto_get_physrand();
}

4
kernel/syscall/randcrypto.h
View File

@ -1,7 +1,9 @@
#ifndef SYSCALL_RANDCRYPTO_H_
#define SYSCALL_RANDCRYPTO_H_
#include "syscall.h"
#include <stdint.h>
#include <stddef.h>
#include "syscall/syscall.h"
int32_t SYSCALL0(sys_rand);

8
kernel/syscall/sched.c
View File

@ -1,10 +1,10 @@
#include <stdint.h>
#include "syscall.h"
#include "sched.h"
#include "syscall/syscall.h"
#include "syscall/sched.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "intr/pit.h"
#include "errors.h"
#include "hal/hal.h"
int32_t SYSCALL0(sys_schedrelease) {
return E_DOSCHEDULING;
@ -12,6 +12,6 @@ int32_t SYSCALL0(sys_schedrelease) {
int32_t SYSCALL1(sys_schedsleep, ms1) {
uint32_t ms = (uint32_t)ms1;
hal_wait(ms);
intr_pit_wait(ms);
return E_OK;
}

3
kernel/syscall/sched.h
View File

@ -2,7 +2,8 @@
#define SYSCALL_SCHED_H_
#include <stdint.h>
#include "syscall.h"
#include <stddef.h>
#include "syscall/syscall.h"
int32_t SYSCALL0(sys_schedrelease);
int32_t SYSCALL1(sys_schedsleep, ms1);

22
kernel/syscall/syscall.c
View File

@ -1,17 +1,17 @@
#include <stdint.h>
#include "syscall.h"
#include "sysdefs/syscall.h"
#include "syscall/syscall.h"
#include "syscall/ipcpipe.h"
#include "syscall/mman.h"
#include "syscall/sched.h"
#include "syscall/randcrypto.h"
#include "syscall/vfs.h"
#include "syscall/proc.h"
#include "syscall/fs.h"
#include "syscall/dev.h"
#include "syscall/time.h"
#include "errors.h"
#include "kprintf.h"
#include "sysdefs/syscall.h"
#include "ipcpipe.h"
#include "mman.h"
#include "sched.h"
#include "randcrypto.h"
#include "vfs.h"
#include "proc.h"
#include "fs.h"
#include "dev.h"
#include "time.h"
int32_t SYSCALL1(sys_debugprint, string) {
char *p = (char *)string;

2
kernel/syscall/syscall.h
View File

@ -3,7 +3,7 @@
#include <stdint.h>
#include "compiler/attr.h"
#include "hal/hal.h"
#include "intr/intr.h"
#define SYSCALLS_MAX 0xff

4
kernel/syscall/time.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall.h"
#include "time.h"
#include "syscall/syscall.h"
#include "syscall/time.h"
#include "sysdefs/time.h"
#include "time/time.h"
#include "errors.h"

1
kernel/syscall/time.h
View File

@ -3,6 +3,7 @@
#include <stdint.h>
#include <stddef.h>
#include "syscall/syscall.h"
int32_t SYSCALL1(sys_time, timestruct1);

16
kernel/syscall/vfs.c
View File

@ -1,10 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include <stdbool.h>
#include "hal/hal.h"
#include "syscall.h"
#include "vfs.h"
#include "errors.h"
#include "syscall/syscall.h"
#include "syscall/vfs.h"
#include "sysdefs/dev.h"
#include "sysdefs/vfs.h"
#include "vfs/vfs.h"
@ -13,7 +11,9 @@
#include "proc/proc.h"
#include "storedev/storedev.h"
#include "util/util.h"
#include "std/string.h"
#include "hshtb.h"
#include "errors.h"
int32_t SYSCALL4(sys_vfsmount, mountpoint1, fstypestr1, devid1, format1) {
int32_t ret = E_OK;
@ -30,7 +30,7 @@ int32_t SYSCALL4(sys_vfsmount, mountpoint1, fstypestr1, devid1, format1) {
int32_t fstype;
if (hal_strcmp(fstypestr, "LittleFS") == 0) {
if (strcmp(fstypestr, "LittleFS") == 0) {
fstype = VFS_LITTLEFS;
} else {
ret = E_INVALIDARGUMENT;
@ -76,7 +76,7 @@ int32_t SYSCALL1(sys_vfsavailmounts, availmounts1) {
for (size_t i = 0; i < VFS_MOUNTPOINTS_MAX; i++) {
VfsMountPoint *vmp = &VFS_TABLE.mountpoints[i];
if (vmp->_hshtbstate == HSHTB_TAKEN) {
hal_memcpy(availmounts->labels[i], vmp->label, VFS_MOUNTPOINT_LABEL_MAX);
memcpy(availmounts->labels[i], vmp->label, VFS_MOUNTPOINT_LABEL_MAX);
availmounts->fieldavail[i] = 1;
}
}
@ -105,7 +105,7 @@ int32_t SYSCALL2(sys_vfsmountstat, statbuf1, label1) {
return E_NOENTRY;
}
hal_memcpy(statbuf->label, vmp->label, sizeof(statbuf->label));
memcpy(statbuf->label, vmp->label, sizeof(statbuf->label));
statbuf->fstype = vmp->fstype;
StoreDev *vmpsd = vmp->backingsd;
@ -113,7 +113,7 @@ int32_t SYSCALL2(sys_vfsmountstat, statbuf1, label1) {
for (size_t i = 0; i < LEN(DEVTABLE.devs); i++) {
Dev *dev = &DEVTABLE.devs[i];
if (dev->extra != NULL && ((StoreDev *)dev->extra)->_magic == STOREDEV_MAGIC && vmpsd == dev->extra) {
hal_memcpy(statbuf->devname, dev->ident, sizeof(statbuf->devname));
memcpy(statbuf->devname, dev->ident, sizeof(statbuf->devname));
break;
}
}

2
kernel/term/term.c
View File

@ -2,7 +2,7 @@
#include "flanterm_backends/fb.h"
#include "spinlock/spinlock.h"
#include "bootinfo/bootinfo.h"
#include "term.h"
#include "term/term.h"
#include "fm-t-437.f16.h"
Term TERM;

7
kernel/time/time.c
View File

@ -1,7 +1,8 @@
#include <stdint.h>
#include <stddef.h>
#include "time.h"
#include "hal/hal.h"
#include "time/time.h"
#include "std/string.h"
#include "io/io.h"
#define CMOS_PORT 0x70
#define CMOS_RETURN 0x71
@ -48,7 +49,7 @@ void time_get(Time *time) {
continue;
}
time_fill(&t2);
if (hal_memcmp(&t1, &t2, sizeof(t1)) == 0) {
if (memcmp(&t1, &t2, sizeof(t1)) == 0) {
break;
}
}

2
kernel/util/util.c
View File

@ -1,7 +1,7 @@
#include <stdint.h>
#include <stddef.h>
#include "util/util.h"
#include "kprintf.h"
#include "util.h"
char *util_get_filename(char *path) {
char *lastslash = path;

37
kernel/vfs/vfs.c
View File

@ -1,17 +1,16 @@
#include <stdint.h>
#include <stddef.h>
#include "vfs.h"
#include "kprintf.h"
#include "vfs/vfs.h"
#include "spinlock/spinlock.h"
#include "hal/hal.h"
#include "util/util.h"
#include "hshtb.h"
#include "assert.h"
#include "errors.h"
#include "fs/portlfs/portlfs.h"
#include "storedev/storedev.h"
#include "baseimg/baseimg.h"
#include "dlmalloc/malloc.h"
#include "std/string.h"
#include "kprintf.h"
#include "errors.h"
#include "hshtb.h"
VfsTable VFS_TABLE;
VfsBusyObjs VFS_BUSY_VOBJS;
@ -19,16 +18,16 @@ VfsBusyObjs VFS_BUSY_VOBJS;
#define CHECK_BUSY_VFSOBJ() \
char *tmpbuf = dlmalloc(VFS_MOUNTPOINT_LABEL_MAX+1+VFS_PATH_MAX); \
\
hal_memset(tmpbuf, 0, VFS_MOUNTPOINT_LABEL_MAX+1+VFS_PATH_MAX); \
hal_string_combine(tmpbuf, mountpoint); \
hal_string_combine(tmpbuf, ":"); \
hal_string_combine(tmpbuf, path); \
memset(tmpbuf, 0, VFS_MOUNTPOINT_LABEL_MAX+1+VFS_PATH_MAX); \
strcat(tmpbuf, mountpoint); \
strcat(tmpbuf, ":"); \
strcat(tmpbuf, path); \
\
bool busy = false; \
VfsObj *vobj, *vobjtmp; \
spinlock_acquire(&VFS_BUSY_VOBJS.spinlock); \
LL_FOREACH_SAFE(VFS_BUSY_VOBJS.vobjs, vobj, vobjtmp) { \
if (hal_strcmp(vobj->path, tmpbuf) == 0) { \
if (strcmp(vobj->path, tmpbuf) == 0) { \
busy = true; \
break; \
} \
@ -39,7 +38,7 @@ VfsBusyObjs VFS_BUSY_VOBJS;
void vfs_init_littlefs(VfsMountPoint *mp, bool format) {
struct lfs_config *cfg = dlmalloc(sizeof(*cfg));
hal_memset(cfg, 0, sizeof(*cfg));
memset(cfg, 0, sizeof(*cfg));
cfg->context = mp;
cfg->read = &portlfs_read;
cfg->prog = &portlfs_prog;
@ -147,7 +146,7 @@ int32_t vfs_mount(char *mountpoint, int32_t fstype, StoreDev *backingsd, bool fo
return E_NOMEMORY;
}
hal_memcpy(mp->label, mountpoint, hal_strlen(mountpoint));
memcpy(mp->label, mountpoint, strlen(mountpoint));
mp->backingsd = backingsd;
mp->fstype = fstype;
switch (fstype) {
@ -178,7 +177,7 @@ int32_t vfs_unmount(char *mountpoint) {
spinlock_release(&mp->spinlock);
return err;
}
hal_memset(mp, 0, sizeof(*mp));
memset(mp, 0, sizeof(*mp));
spinlock_release(&mp->spinlock);
return E_OK;
}
@ -205,9 +204,9 @@ VfsObj *vfs_open(char *mountpoint, const char *path, uint32_t flags) {
return NULL;
}
hal_string_combine(vobj1->path, mountpoint);
hal_string_combine(vobj1->path, ":");
hal_string_combine(vobj1->path, path);
strcat(vobj1->path, mountpoint);
strcat(vobj1->path, ":");
strcat(vobj1->path, path);
spinlock_acquire(&VFS_BUSY_VOBJS.spinlock);
LL_APPEND(VFS_BUSY_VOBJS.vobjs, vobj1);
@ -224,9 +223,9 @@ void vfs_close(VfsObj *vobj) {
}
void vfs_init(void) {
hal_memset(&VFS_TABLE, 0, sizeof(VFS_TABLE));
memset(&VFS_TABLE, 0, sizeof(VFS_TABLE));
spinlock_init(&VFS_TABLE.spinlock);
hal_memset(&VFS_BUSY_VOBJS, 0, sizeof(VFS_BUSY_VOBJS));
memset(&VFS_BUSY_VOBJS, 0, sizeof(VFS_BUSY_VOBJS));
spinlock_init(&VFS_BUSY_VOBJS.spinlock);
{

127
kernel/vmm/vmm.c Normal file
View File

@ -0,0 +1,127 @@
#include <stddef.h>
#include <stdint.h>
#include "vmm/vmm.h"
#include "bootinfo/bootinfo.h"
#include "pmm/pmm.h"
#include "proc/proc.h"
#include "spinlock/spinlock.h"
#include "std/string.h"
#include "kprintf.h"
uint64_t KERNEL_CR3 = 0;
SpinLock spinlock;
uint64_t vmm_current_cr3(void) {
uint64_t cr3;
asm volatile("mov %%cr3, %0" : "=r"(cr3));
return cr3;
}
PgIndex vmm_pageindex(uint64_t vaddr) {
PgIndex ret;
ret.pml4 = (vaddr >> 39) & 0x1ff;
ret.pml3 = (vaddr >> 30) & 0x1ff;
ret.pml2 = (vaddr >> 21) & 0x1ff;
ret.pml1 = (vaddr >> 12) & 0x1ff;
return ret;
}
uint64_t *vmm_nexttable(uint64_t *table, uint64_t ent, bool alloc) {
uint64_t entry = table[ent];
uint64_t phys;
if (entry & VMM_PG_PRESENT) {
phys = entry & ~0xFFFULL;
} else {
if (!alloc) {
return NULL;
}
uint8_t *newphys = pmm_alloc(1);
phys = (uint64_t)newphys;
memset(VIRT(phys), 0, VMM_PAGE_SIZE);
table[ent] = phys | VMM_PG_USER | VMM_PG_RW | VMM_PG_PRESENT;
}
return (uint64_t *)((uint8_t *)VIRT(phys));
}
void vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags) {
uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
PgIndex pi = vmm_pageindex(virtaddr);
uint64_t *pml3 = vmm_nexttable(pml4, pi.pml4, true);
uint64_t *pml2 = vmm_nexttable(pml3, pi.pml3, true);
uint64_t *pml1 = vmm_nexttable(pml2, pi.pml2, true);
uint64_t *pte = &pml1[pi.pml1];
*pte = (physaddr & ~0xFFFULL) | ((uint64_t)flags & 0x7ULL);
}
void vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr) {
uint64_t *pml4 = (uint64_t *)VIRT(cr3phys);
PgIndex pi = vmm_pageindex(virtaddr);
uint64_t *pml3 = vmm_nexttable(pml4, pi.pml4, false);
uint64_t *pml2 = vmm_nexttable(pml3, pi.pml3, false);
uint64_t *pml1 = vmm_nexttable(pml2, pi.pml2, false);
uint64_t *pte = &pml1[pi.pml1];
*pte &= ~VMM_PG_PRESENT;
}
void vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags) {
if (size % VMM_PAGE_SIZE != 0 || (uint64_t)virtstart % VMM_PAGE_SIZE != 0 || (uint64_t)physstart % VMM_PAGE_SIZE != 0) {
return;
}
spinlock_acquire(&spinlock);
uint8_t *vaddr = (uint8_t *)virtstart;
uint8_t *paddr = (uint8_t *)physstart;
uint8_t *end = (uint8_t *)virtstart + size;
for (; vaddr < end; vaddr += VMM_PAGE_SIZE, paddr += VMM_PAGE_SIZE) {
vmm_map_page(cr3phys, (uint64_t)vaddr, (uint64_t)paddr, flags);
}
spinlock_release(&spinlock);
}
void vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size) {
if (size % VMM_PAGE_SIZE != 0 || (uint64_t)virtstart % VMM_PAGE_SIZE != 0 || (uint64_t)physstart % VMM_PAGE_SIZE != 0) {
return;
}
spinlock_acquire(&spinlock);
uint8_t *vaddr = (uint8_t *)virtstart;
uint8_t *end = vaddr + size;
for (; vaddr < end; vaddr += VMM_PAGE_SIZE) {
vmm_unmap_page(cr3phys, (uint64_t)vaddr);
}
spinlock_release(&spinlock);
}
void vmm_map_kern(uint64_t targetcr3) {
uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
uint64_t *cr3 = (uint64_t *)VIRT(targetcr3);
for (size_t i = 0; i < 512; i++) {
cr3[i] = kcr3[i];
}
}
uint64_t vmm_userproc_pml4_phys(void) {
uint8_t *cr3phys = pmm_alloc(1);
uint64_t phys = (uint64_t)cr3phys;
memset(VIRT(phys), 0, VMM_PAGE_SIZE);
uint64_t *kcr3 = (uint64_t *)VIRT(KERNEL_CR3);
uint64_t *pml4 = (uint64_t *)VIRT(phys);
for (size_t i = 256; i < 512; i++) {
pml4[i] = kcr3[i];
}
return phys;
}
void vmm_init(void) {
spinlock_init(&spinlock);
KERNEL_CR3 = vmm_current_cr3();
}

28
kernel/hal/x86_64/vmm.h → kernel/vmm/vmm.h
View File

@ -1,11 +1,13 @@
#ifndef HAL_VMM_H_
#define HAL_VMM_H_
#ifndef VMM_VMM_H_
#define VMM_VMM_H_
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "compiler/attr.h"
#define VMM_PAGE_SIZE 0x1000
#define VIRT(X) ((void *)(BOOT_INFO.hhdm_off + (uint64_t)(X)))
typedef struct VasRange {
@ -18,9 +20,9 @@ typedef struct VasRange {
} PACKED VasRange;
enum {
HAL_PG_PRESENT = 1<<0,
HAL_PG_RW = 1<<1,
HAL_PG_USER = 1<<2,
VMM_PG_PRESENT = 1<<0,
VMM_PG_RW = 1<<1,
VMM_PG_USER = 1<<2,
};
typedef struct {
@ -52,12 +54,12 @@ typedef struct {
extern uint64_t KERNEL_CR3;
void hal_vmm_init(void);
void hal_vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr);
void hal_vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags);
uint64_t hal_vmm_current_cr3(void);
void hal_vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags);
void hal_vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size);
uint64_t hal_vmm_userproc_pml4_phys();
void vmm_init(void);
void vmm_unmap_page(uint64_t cr3phys, uint64_t virtaddr);
void vmm_map_page(uint64_t cr3phys, uint64_t virtaddr, uint64_t physaddr, uint32_t flags);
uint64_t vmm_current_cr3(void);
void vmm_map_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size, uint32_t flags);
void vmm_unmap_range(uint64_t cr3phys, void *virtstart, void *physstart, size_t size);
uint64_t vmm_userproc_pml4_phys(void);
#endif // HAL_VMM_H_
#endif // VMM_VMM_H_