freya/corn
1
0
Fork 0
mirror of https://git.stationery.faith/corn/corn.git synced 2024-11-24 09:12:18 +00:00
Code Issues Projects Releases Packages Wiki Activity

follow the corn style guide

Browse source
This commit is contained in:
trimill 2024-01-31 22:30:35 -05:00
parent ef384ad9a7
commit b5b904cfc9
No known key found for this signature in database
GPG key ID: 4F77A16E17E10BCB
21 changed files with 166 additions and 203 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
include/backtrace.h
View file

@ -7,7 +7,7 @@
size_t backtrace(void **dst, size_t len);
// same as backtrace but with specified instruction and base pointer
size_t backtrace_ex(void **dst, size_t len, void* ip, void *bp);
size_t backtrace_ex(void **dst, size_t len, void *ip, void *bp);
// Log a backtrace
void log_backtrace();

14
include/lib.h
View file

@ -92,25 +92,25 @@ int ctoi(char c);
* @param s - the string to convert
* @returns the number inside s or 0 on error
*/
int atoi(const char* s);
int atoi(const char *s);
/**
* Converts the initial portiion of the string pointed to by s to long.
* @param s - the string to convert
* @returns the number inside s or 0 on error
*/
long int atol(const char* s);
long int atol(const char *s);
/**
* Converts the initial portiion of the string pointed to by s to long long.
* @param s - the string to convert
* @returns the number inside s or 0 on error
*/
long long int atoll(const char* s);
long long int atoll(const char *s);
/**
* Converts a integer to asci inside a string with a given radix (base).
* @param n - the number to conver
* @param n - the number to convert
* @param buffer - the string buffer
* @param radix - the base to convert
*/
@ -118,7 +118,7 @@ char *itoa(int n, char *buffer, int radix);
/**
* Converts a long to asci inside a string with a given radix (base).
* @param n - the number to conver
* @param n - the number to convert
* @param buffer - the string buffer
* @param radix - the base to convert
*/
@ -134,7 +134,7 @@ char *lltoa(long long int n, char *buffer, int radix);
/**
* Converts a unsigned integer to asci inside a string with a given radix (base).
* @param n - the number to conver
* @param n - the number to convert
* @param buffer - the string buffer
* @param radix - the base to convert
*/
@ -142,7 +142,7 @@ char *utoa(unsigned int n, char *buffer, int radix);
/**
* Converts a unsigned long to asci inside a string with a given radix (base).
* @param n - the number to conver
* @param n - the number to convert
* @param buffer - the string buffer
* @param radix - the base to convert
*/

30
include/memory.h
View file

@ -7,46 +7,46 @@
/**
* Initalize system memory allocator
*/
extern void memory_init(struct memory_map *map);
void memory_init(struct memory_map *map);
/**
* Disabled cpu interupts to not interfere with
* current memory allocations.
*/
extern void memory_lock(void);
void memory_lock(void);
/**
* Reenabled cpu interupts
*/
extern void memory_unlock(void);
void memory_unlock(void);
/**
* @returns how much memory the system has
*/
extern uint64_t memory_total(void);
uint64_t memory_total(void);
/**
* @returns how much memory is free
*/
extern uint64_t memory_free(void);
uint64_t memory_free(void);
/**
* @returns how much memory is used
*/
extern uint64_t memory_used(void);
uint64_t memory_used(void);
/**
* Allocates a single page in memory.
* @returns the page if allocated or NULL on failure
*/
extern void *alloc_page(void);
void *alloc_page(void);
/**
* Allocats count pages in memory
* @param count - the number of continious pages to allocate
* @returns the pages if allocated or NULL on failure
*/
extern void *alloc_pages(int count);
void *alloc_pages(int count);
/**
* Frees a signle page in memory.
@ -54,7 +54,7 @@ extern void *alloc_pages(int count);
* Freeing in the middle of a block is allowed.
* @param page - the pointer to the page
*/
extern void free_page(void *page);
void free_page(void *page);
// TODO: implement free_page
/**
@ -64,7 +64,7 @@ extern void free_page(void *page);
* free_pages will from *page to end of block allocated.
* @param page - the pointer to the page
*/
extern void free_pages(void *page);
void free_pages(void *page);
// TODO: implement freeing in middle of block
/**
@ -76,21 +76,21 @@ extern void free_pages(void *page);
* @param writable - if this memory should be writable
* @param user - if this memory should be user writable
*/
extern void *mmap(void *addr, size_t len);
void *mmap(void *addr, size_t len);
/**
* Unmaps mapped address from the mmap function
* @param addr - the address returned from mmap
* @param len - the length allocated
*/
extern void unmap(void *addr);
void unmap(void *addr);
/**
* Allocates size_t bytes in memory
* @param size - the amount of bytes to allocate
* @retruns the address allocated or NULL on failure
*/
extern void *kalloc(size_t size);
void *kalloc(size_t size);
/**
* Reallocates a given allocated ptr to a new size of bytes in memory.
@ -99,10 +99,10 @@ extern void *kalloc(size_t size);
* @param size - the amount of bytes to set the pointer to
* @returns the address allocated or NULL on failure
*/
extern void *krealloc(void *ptr, size_t size);
void *krealloc(void *ptr, size_t size);
/**
* Frees a allocated pointer in memory
* @param ptr - the pointer to free
*/
extern void kfree(void *ptr);
void kfree(void *ptr);

8
include/memory/physalloc.h
View file

@ -8,23 +8,23 @@
* Allocates a single physical page in memory
* @preturns the physical address of the page
*/
extern void *alloc_phys_page(void);
void *alloc_phys_page(void);
/**
* Allocates count physical pages in memory
* @returns the physical address of the first page
*/
extern void *alloc_phys_pages(int count);
void *alloc_phys_pages(int count);
/**
* Frees a single physical page in memory
* @param ptr - the physical address of the page
*/
extern void free_phys_page(void *ptr);
void free_phys_page(void *ptr);
/**
* Frees count physical pages in memory
* @param ptr - the physical address of the first page
* @param count - the number of pages in the list
*/
extern void free_phys_pages(void *ptr, int count);
void free_phys_pages(void *ptr, int count);

14
src/arch/amd64/acpi.c
View file

@ -162,13 +162,13 @@ static bool checksum(uint8_t *data, size_t len) {
static int read_s5_addr(struct acpi_state *state) {
uintptr_t ptr = state->fadt.dsdt;
char *s5_addr = (void*) (ptr + 36);
char *s5_addr = (void *) (ptr + 36);
int dsdt_len = *((int*) (ptr+1)) - 36;
int dsdt_len = *((int *) (ptr+1)) - 36;
while (0 < dsdt_len--) {
if ( memcmp(s5_addr, "_S5_", 4) == 0)
break;
s5_addr++;
if (memcmp(s5_addr, "_S5_", 4) == 0)
break;
s5_addr++;
}
if (dsdt_len > 0) {
@ -178,12 +178,12 @@ static int read_s5_addr(struct acpi_state *state) {
s5_addr += ((*s5_addr &0xC0)>>6) +2; // calculate PkgLength size
if (*s5_addr == 0x0A)
s5_addr++; // skip byteprefix
s5_addr++; // skip byteprefix
state->SLP_TYPa = *(s5_addr)<<10;
s5_addr++;
if (*s5_addr == 0x0A)
s5_addr++; // skip byteprefix
s5_addr++; // skip byteprefix
state->SLP_TYPb = *(s5_addr)<<10;
state->SLP_EN = 1<<13;

6
src/arch/amd64/backtrace.c
View file

@ -16,11 +16,11 @@ size_t backtrace(void **dst, size_t len) {
size_t backtrace_ex(void **dst, size_t len, void *ip, void *bp) {
struct stackframe *frame = bp;
__asm__ volatile ("mov %%rbp, %0" : "=r"(frame));
if(len > 0) {
if (len > 0) {
dst[0] = ip;
}
size_t i;
for(i = 1; frame && i < len; i++) {
for (i = 1; frame && i < len; i++) {
dst[i] = frame->rip;
frame = frame->rbp;
}
@ -42,7 +42,7 @@ void log_backtrace_ex(void *ip, void *bp) {
serial_out_str(" 0x");
serial_out_str(buf);
serial_out_str("\n");
while(frame) {
while (frame) {
ultoa((size_t)frame->rip, buf, 16);
serial_out_str(" 0x");
serial_out_str(buf);

30
src/arch/amd64/boot.S
View file

@ -61,25 +61,25 @@ LONG_MODE equ 1 << 5
GDT:
.Null: equ $ - GDT
dq 0
dq 0
.Code: equ $ - GDT
dd 0xFFFF ; Limit & Base (low, bits 0-15)
db 0 ; Base (mid, bits 16-23)
db PRESENT | NOT_SYS | EXEC | RW ; Access
db GRAN_4K | LONG_MODE | 0xF ; Flags & Limit (high, bits 16-19)
db 0 ; Base (high, bits 24-31)
dd 0xFFFF ; Limit & Base (low, bits 0-15)
db 0 ; Base (mid, bits 16-23)
db PRESENT | NOT_SYS | EXEC | RW ; Access
db GRAN_4K | LONG_MODE | 0xF ; Flags & Limit (high, bits 16-19)
db 0 ; Base (high, bits 24-31)
.Data: equ $ - GDT
dd 0xFFFF ; Limit & Base (low, bits 0-15)
db 0 ; Base (mid, bits 16-23)
db PRESENT | NOT_SYS | RW ; Access
db GRAN_4K | SZ_32 | 0xF ; Flags & Limit (high, bits 16-19)
db 0 ; Base (high, bits 24-31)
dd 0xFFFF ; Limit & Base (low, bits 0-15)
db 0 ; Base (mid, bits 16-23)
db PRESENT | NOT_SYS | RW ; Access
db GRAN_4K | SZ_32 | 0xF ; Flags & Limit (high, bits 16-19)
db 0 ; Base (high, bits 24-31)
.TSS: equ $ - GDT
dd 0x00000068
dd 0x00CF8900
dd 0x00000068
dd 0x00CF8900
.Pointer:
dw $ - GDT - 1
dq GDT
dw $ - GDT - 1
dq GDT
section .text
align 8

4
src/arch/amd64/fb.c
View file

@ -9,8 +9,8 @@
#define INDEX 0x1CE
#define DATA 0x1CF
#define FB_ADDR 0xE0000000
#define FB_MAX 0xFF000000
#define FB_LEN (FB_MAX - FB_ADDR)
#define FB_MAX 0xFF000000
#define FB_LEN (FB_MAX - FB_ADDR)
#define PREFERRED_VY 4096
#define PREFERRED_B 32

6
src/arch/amd64/idt.c
View file

@ -53,8 +53,8 @@ void idt_init(void) {
idtr.size = (uint16_t)sizeof(struct idt_entry) * IDT_SIZE - 1;
// initialize idt
for(size_t vector = 0; vector < IDT_SIZE; vector++) {
struct idt_entry* entry = &idt[vector];
for (size_t vector = 0; vector < IDT_SIZE; vector++) {
struct idt_entry *entry = &idt[vector];
uint64_t isr = (uint64_t)isr_stub_table[vector];
// interrupts before 0x20 are for cpu exceptions
@ -120,7 +120,7 @@ void idt_exception_handler(uint64_t exception, uint64_t code, void *rip, void *r
strcat(msg, buf);
// page faults store the offending address in cr2
if(exception == 0x0E) {
if (exception == 0x0E) {
strcat(msg, "\nPage fault address: 0x");
void *addr;
__asm__ volatile ("mov %%cr2, %0" : "=r"(addr));

112
src/arch/amd64/mboot.c
View file

@ -13,81 +13,73 @@
#define MBOOT_OLD_RSDP 14
#define MBOOT_NEW_RSDP 15
extern char symtab;
#define kaddr(addr) ((uintptr_t)(&addr))
typedef uint8_t mboot_uint8_t;
typedef uint16_t mboot_uint16_t;
typedef uint32_t mboot_uint32_t;
typedef uint64_t mboot_uint64_t;
struct mboot_info {
mboot_uint32_t total_size;
mboot_uint32_t reserved;
uint32_t total_size;
uint32_t reserved;
char tags[];
};
struct mboot_tag {
mboot_uint32_t type;
mboot_uint32_t size;
uint32_t type;
uint32_t size;
char data[];
};
struct mboot_tag_elf_sections {
mboot_uint32_t type;
mboot_uint32_t size;
mboot_uint16_t num;
mboot_uint16_t entsize;
mboot_uint16_t shndx;
mboot_uint16_t reserved;
uint32_t type;
uint32_t size;
uint16_t num;
uint16_t entsize;
uint16_t shndx;
uint16_t reserved;
char sections[];
};
struct mboot_tag_elf_sections_entry {
mboot_uint32_t sh_name;
mboot_uint32_t sh_type;
mboot_uint64_t sh_flags;
mboot_uint64_t sh_addr;
mboot_uint64_t sh_offset;
mboot_uint64_t sh_size;
mboot_uint32_t sh_link;
mboot_uint32_t sh_info;
mboot_uint64_t sh_addralign;
mboot_uint64_t sh_entsize;
uint32_t sh_name;
uint32_t sh_type;
uint64_t sh_flags;
uint64_t sh_addr;
uint64_t sh_offset;
uint64_t sh_size;
uint32_t sh_link;
uint32_t sh_info;
uint64_t sh_addralign;
uint64_t sh_entsize;
};
struct mboot_mmap_entry {
mboot_uint64_t addr;
mboot_uint64_t len;
mboot_uint32_t type;
mboot_uint32_t zero;
uint64_t addr;
uint64_t len;
uint32_t type;
uint32_t zero;
};
struct mboot_tag_mmap {
mboot_uint32_t type;
mboot_uint32_t size;
mboot_uint32_t entry_size;
mboot_uint32_t entry_version;
uint32_t type;
uint32_t size;
uint32_t entry_size;
uint32_t entry_version;
struct mboot_mmap_entry entries[];
};
struct mboot_tag_old_rsdp {
mboot_uint32_t type;
mboot_uint32_t size;
mboot_uint8_t rsdp[];
uint32_t type;
uint32_t size;
uint8_t rsdp[];
};
struct mboot_tag_new_rsdp {
mboot_uint32_t type;
mboot_uint32_t size;
mboot_uint8_t rsdp[];
uint32_t type;
uint32_t size;
uint8_t rsdp[];
};
struct mboot_tag_cmdline {
mboot_uint32_t type;
mboot_uint32_t size;
mboot_uint8_t cmdline[];
uint32_t type;
uint32_t size;
uint8_t cmdline[];
};
static void read_symbols(
@ -100,33 +92,33 @@ static void read_symbols(
// struct mboot_elf_section_header *section =
// (struct mboot_elf_section_header *) (layout->elf_section_headers);
//
// for (mboot_uint32_t i = 0; i < layout->num; i++) {
// for (uint32_t i = 0; i < layout->num; i++) {
// char buf[20];
//
// ultoa(i, buf, 10);
// serial_out_str("[");
// serial_out_str(buf);
// serial_out_str("]\t");
// serial_out_str(buf);
// serial_out_str("]\t");
//
// serial_out_str((char *)(kaddr(symtab) + section->sh_name));
// serial_out('\t');
//
// ultoa(section->sh_type, buf, 16);
// serial_out_str("type: 0x");
// serial_out_str(buf);
// serial_out('\t');
// serial_out_str(buf);
// serial_out('\t');
//
// ultoa(section->sh_addr, buf, 16);
// serial_out_str("addr: 0x");
// serial_out_str(buf);
// serial_out('\t');
// ultoa(section->sh_addr, buf, 16);
// serial_out_str("addr: 0x");
// serial_out_str(buf);
// serial_out('\t');
//
// ultoa(section->sh_offset, buf, 16);
// serial_out_str("offset: 0x");
// serial_out_str(buf);
// serial_out('\n');
// ultoa(section->sh_offset, buf, 16);
// serial_out_str("offset: 0x");
// serial_out_str(buf);
// serial_out('\n');
//
// section++;
// section++;
// }
}
@ -134,7 +126,7 @@ static void read_cmdline(
struct boot_info *shim_info,
struct mboot_tag_cmdline *cmdline
) {
mboot_uint32_t size = cmdline->size - 8;
uint32_t size = cmdline->size - 8;
if (size >= CMDLINE_MAX)
size = CMDLINE_MAX; // truncate :(
memcpy(shim_info->cmdline, cmdline->cmdline, size);

69
src/arch/amd64/paging.c
View file

@ -68,25 +68,18 @@ static struct pdpte *pdpt_mapped = (void *) (uintptr_t) 0x201000;
static struct pde *pd_mapped = (void *) (uintptr_t) 0x202000;
static struct pte *pt_mapped = (void *) (uintptr_t) 0x203000;
static inline void
invlpg(void *addr)
{
static inline void invlpg(void *addr) {
__asm volatile("invlpg (%0)" ::"r" (addr) : "memory");
}
static void
load_addr(void *phys_addr)
{
static void load_addr(void *phys_addr) {
static struct pte *pt = &paging_pt[4];
pt->address = (uint64_t)phys_addr >> 12;
pt->flags = F_PRESENT | F_WRITEABLE;
invlpg(addr_mapped);
}
static void
load_pml4(
void *phys
) {
static void load_pml4(void *phys) {
static struct pte *pt = &paging_pt[0];
if ((uint64_t)phys >> 12 == pt->address)
return;
@ -95,10 +88,7 @@ load_pml4(
invlpg(pml4_mapped);
}
static void
load_pdpt(
void *phys
) {
static void load_pdpt(void *phys) {
static struct pte *pt = &paging_pt[1];
if ((uint64_t)phys >> 12 == pt->address)
return;
@ -107,10 +97,7 @@ load_pdpt(
invlpg(pdpt_mapped);
}
static void
load_pd(
void *phys
) {
static void load_pd(void *phys) {
static struct pte *pt = &paging_pt[2];
if ((uint64_t)phys >> 12 == pt->address)
return;
@ -119,10 +106,7 @@ load_pd(
invlpg(pdpt_mapped);
}
static void
load_pt(
void *phys
) {
static void load_pt(void *phys) {
static struct pte *pt = &paging_pt[3];
if ((uint64_t)phys >> 12 == pt->address)
return;
@ -135,8 +119,7 @@ load_pt(
#define PAG_CANNOT_ALLOC 1
#define PAG_NOT_PRESENT 2
static int
select_pdpt(
static int select_pdpt(
void *virt,
unsigned int flags,
struct pml4e *root,
@ -165,8 +148,7 @@ select_pdpt(
return PAG_SUCCESS;
}
static int
select_pd(
static int select_pd(
void *virt,
unsigned int flags,
struct pdpte *pdpt,
@ -195,8 +177,7 @@ select_pd(
return PAG_SUCCESS;
}
static int
select_pt(
static int select_pt(
void *virt,
unsigned int flags,
struct pde *pd,
@ -225,8 +206,7 @@ select_pt(
return PAG_SUCCESS;
}
static void
select_page(
static void select_page(
void *virt,
struct pte *pt,
struct pte **res
@ -238,8 +218,7 @@ select_page(
return;
}
static inline void
try_unmap_pml4(void) {
static inline void try_unmap_pml4(void) {
for (int i = 0; i < 512; i++) {
if (pml4_mapped[i].flags & F_PRESENT)
return;
@ -252,8 +231,7 @@ try_unmap_pml4(void) {
}
}
static inline void
try_unmap_pdpt(void) {
static inline void try_unmap_pdpt(void) {
for (int i = 0; i < 512; i++) {
if (pdpt_mapped[i].flags & F_PRESENT)
return;
@ -267,8 +245,7 @@ try_unmap_pdpt(void) {
try_unmap_pml4();
}
static inline void
try_unmap_pd(void) {
static inline void try_unmap_pd(void) {
for (int i = 0; i < 512; i++) {
if (pd_mapped[i].flags & F_PRESENT)
return;
@ -282,8 +259,7 @@ try_unmap_pd(void) {
try_unmap_pdpt();
}
static inline void
try_unmap_pt(void) {
static inline void try_unmap_pt(void) {
for (int i = 0; i < 512; i++) {
if (pt_mapped[i].flags & F_PRESENT)
return;
@ -297,12 +273,10 @@ try_unmap_pt(void) {
try_unmap_pd();
}
static void
unmap_page(
static void unmap_page(
struct pml4e *root,
void *virt
) {
struct pdpte *pdpt;
struct pde *pd;
struct pte *pt;
@ -331,13 +305,11 @@ unmap_page(
return;
}
static void
unmap_pages(
static void unmap_pages(
struct pml4e *root,
void *virt_start,
long page_count
) {
uint64_t pml4_o = -1,
pdpt_o = -1,
pd_o = -1;
@ -397,14 +369,12 @@ unmap_pages(
return;
}
static int
map_page(
static int map_page(
struct pml4e *root,
void *virt,
void *phys,
unsigned int flags
) {
struct pdpte *pdpt;
struct pde *pd;
struct pte *pt;
@ -430,15 +400,13 @@ map_page(
return 0;
}
static int
map_pages(
static int map_pages(
struct pml4e *root,
void *virt_start,
void *phys_start,
unsigned int flags,
long page_count
) {
uint64_t pml4_o = -1,
pdpt_o = -1,
pd_o = -1;
@ -502,7 +470,6 @@ failed:
}
void paging_init(void) {
kernel_pml4[0].flags = F_PRESENT | F_WRITEABLE;
kernel_pml4[0].address = (uint64_t)(&kernel_pdpt_0) >> 12;

6
src/arch/amd64/pic.c
View file

@ -53,7 +53,7 @@ void pic_remap(void) {
void pic_mask(int irq) {
uint16_t port;
uint8_t mask;
if(irq < 8) {
if (irq < 8) {
port = PIC1_DATA;
} else {
port = PIC2_DATA;
@ -66,7 +66,7 @@ void pic_mask(int irq) {
void pic_unmask(int irq) {
uint16_t port;
uint8_t mask;
if(irq < 8) {
if (irq < 8) {
port = PIC1_DATA;
} else {
irq -= 8;
@ -82,7 +82,7 @@ void pic_disable(void) {
}
void pic_eoi(int irq) {
if(irq >= 8) {
if (irq >= 8) {
outb(PIC2_COMMAND, PIC_EOI);
}
outb(PIC1_COMMAND, PIC_EOI);

8
src/arch/amd64/serial.c
View file

@ -18,7 +18,7 @@ int serial_init(void) {
outb(PORT + 0, 0xAE); // test by sending 0xAE
uint8_t response = inb(PORT + 0);
if(response != 0xAE) {
if (response != 0xAE) {
// TODO panic here?
return -1;
}
@ -30,18 +30,18 @@ int serial_init(void) {
uint8_t serial_in(void) {
// wait for data to be available
while((inb(PORT + 5) & 0x01) == 0);
while ((inb(PORT + 5) & 0x01) == 0);
return inb(PORT);
}
void serial_out(uint8_t ch) {
// wait for output to be free
while((inb(PORT + 5) & 0x20) == 0);
while ((inb(PORT + 5) & 0x20) == 0);
outb(PORT, ch);
}
void serial_out_str(const char *str) {
for(; *str != '\0'; str++) {
for (; *str != '\0'; str++) {
serial_out(*str);
}
}

2
src/arch/amd64/shim.c
View file

@ -11,7 +11,7 @@
static struct boot_info boot_info;
void* amd64_shim(long mboot_magic, void *mboot_data_ptr) {
void *amd64_shim(long mboot_magic, void *mboot_data_ptr) {
serial_init();
paging_init();
pic_remap();

4
src/kmain.c
View file

@ -12,8 +12,8 @@ void kmain(struct boot_info *info) {
kprintf("enterd kmain\n");
*(char*)(0xB8000 + 0x144) = 'h';
*(char*)(0xB8000 + 0x146) = 'i';
*(char *)(0xB8000 + 0x144) = 'h';
*(char *)(0xB8000 + 0x146) = 'i';
while (1) {
//kprintf("ret: 0x%p\n", kalloc(1024));

38
src/lib.c
View file

@ -45,19 +45,21 @@ int strncmp(const char *restrict lhs, const char *restrict rhs, unsigned long n)
}
char *strcpy(char *restrict dest, const char *restrict src) {
for(; (*dest = *src); dest++, src++);
char *d = dest;
for (; (*d = *src); d++, src++);
return dest;
}
char *strncpy(char *restrict dest, const char *restrict src, unsigned long n) {
for(; (*dest = *src) && n; dest++, src++, n--);
memset(dest, 0, n);
char *d = dest;
for (; (*d = *src) && n; d++, src++, n--);
memset(d, 0, n);
return dest;
}
size_t strlen(const char *str) {
const char *p;
for(p = str; *p != 0; p++) {}
for (p = str; *p != 0; p++) {}
return p - str;
}
@ -86,8 +88,8 @@ int isdigit(int c) {
#define ATOX(name, type) \
type name(const char* s) { \
for(; isspace(*s); s++); \
type name(const char *s) { \
for (; isspace(*s); s++); \
int neg = 0; \
switch (*s) { \
case '-': \
@ -111,7 +113,7 @@ ATOX(atol, long int)
ATOX(atoll, long long int)
char itoc(int i) {
if(i < 10) {
if (i < 10) {
return '0' + i;
} else {
return 'a' + (i - 10);
@ -119,9 +121,9 @@ char itoc(int i) {
}
int ctoi(char c) {
if(c < 'A') {
if (c < 'A') {
return c - '0';
} else if(c < 'a') {
} else if (c < 'a') {
return c - 'A' + 10;
} else {
return c - 'a' + 10;
@ -216,13 +218,14 @@ end:
for (; n; n /= radix) { \
*buffer++ = itoc(n % radix); \
} \
char *buf_end = buffer; \
*buffer-- = '\0'; \
while(buffer > start) { \
while (buffer > start) { \
char tmp = *start; \
*start++ = *buffer; \
*buffer-- = tmp; \
} \
return buffer; \
return buf_end; \
}
UXTOA(int, utoa)
@ -230,7 +233,7 @@ UXTOA(long int, ultoa)
UXTOA(long long int, ulltoa)
#define XTOA(type, name) \
char *name(type n, char* buffer, int radix) { \
char *name(type n, char *buffer, int radix) { \
if (n == 0) { \
buffer[0] = '0'; \
buffer[1] = '\0'; \
@ -244,13 +247,14 @@ UXTOA(long long int, ulltoa)
for (; n; n /= radix) { \
*buffer++ = itoc(n % radix); \
} \
char *buf_end = buffer; \
*buffer-- = '\0'; \
while(buffer > start) { \
while (buffer > start) { \
char tmp = *start; \
*start++ = *buffer; \
*buffer-- = tmp; \
} \
return buffer; \
return buf_end; \
}
XTOA(int, itoa)
@ -260,7 +264,7 @@ XTOA(long long int, lltoa)
#define STRTOX(name, type) \
type name(const char *s, char **endptr, int radix) { \
*endptr = NULL; \
for(; isspace(*s); s++); \
for (; isspace(*s); s++); \
int neg = 0; \
switch (*s) { \
case '-': \
@ -283,9 +287,9 @@ XTOA(long long int, lltoa)
radix = 10; \
} \
} \
for (; *s == '0'; s++, *endptr = (void*) s); \
for (; *s == '0'; s++, *endptr = (void *) s); \
type num = 0; \
for (; isdigit(*s); s++, *endptr = (void*) s) { \
for (; isdigit(*s); s++, *endptr = (void *) s) { \
num *= radix; \
num += *s - '0'; \
} \

2
src/memory/memory.c
View file

@ -19,7 +19,7 @@ static const size_t header_len = sizeof(struct page_header);
static struct page_header *start_header = NULL;
static struct page_header *end_header = NULL;
struct page_header* get_header(void *ptr) {
struct page_header *get_header(void *ptr) {
struct page_header *header =
(struct page_header *) ((uintptr_t) ptr - header_len);

4
src/memory/physalloc.c
View file

@ -170,7 +170,7 @@ void memory_init(struct memory_map *map) {
segment_count = 0;
for(uint32_t i = 0; i < map->entry_count; i++) {
for (uint32_t i = 0; i < map->entry_count; i++) {
struct memory_segment *segment = &map->entries[i];
if (segment_invalid(segment))
@ -201,7 +201,7 @@ void memory_init(struct memory_map *map) {
struct memory_area *area = page_start;
kprintf("MEMORY MAP\n");
for(uint32_t i = 0; i < map->entry_count; i++) {
for (uint32_t i = 0; i < map->entry_count; i++) {
struct memory_segment *segment = &map->entries[i];
if (segment_invalid(segment))

4
src/memory/virtalloc.c
View file

@ -118,7 +118,7 @@ void *virtaddr_alloc(int n_pages) {
}
static void merge_back(struct addr_node *node) {
while(node->prev && !node->is_alloc) {
while (node->prev && !node->is_alloc) {
struct addr_node *temp = node->prev;
node->start = node->prev->start;
node->prev = node->prev->prev;
@ -130,7 +130,7 @@ static void merge_back(struct addr_node *node) {
}
static void merge_forward(struct addr_node *node) {
while(node->next && !node->is_alloc) {
while (node->next && !node->is_alloc) {
struct addr_node *temp = node->next;
node->end = node->next->end;
node->next = node->next->next;