os-k-team/os-k
os-k-team/os-k
1
0
Fork 0
mirror of https://gitlab.os-k.eu/os-k-team/os-k.git synced 2023-08-25 14:03:10 +02:00
Code Releases Activity

allocation

Browse Source
This commit is contained in:
Adrien Bourmault 2019-03-18 18:00:40 +01:00
commit 8a7b559fe9
20 changed files with 407 additions and 62 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Makefile
View File

@ -32,11 +32,11 @@ CCNAME=x86_64-elf-gcc
ASMFLAGS=-f elf64
LDFLAGS=-melf_x86_64
COPTIM=-O2
CWARNS=-Wall -Wextra # -Werror=implicit-function-declaration
CWARNS=-Wall -Wextra -Werror=implicit-function-declaration
CINCLUDES=-Ikaleid/include
CFLAGS1=-nostdlib -ffreestanding -mcmodel=large # -std=gnu11
CFLAGS1=-nostdlib -ffreestanding -mcmodel=large -std=gnu11
CFLAGS2= -c -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -fno-strict-aliasing
CFLAGS=$(CFLAGS1) $(CFLAGS2) -DNDEBUG
CFLAGS=$(CFLAGS1) $(CFLAGS2)
KCC=$(CCNAME) $(COPTIM) $(CWARNS) $(CFLAGS) $(CINCLUDES) -D_OSK_SOURCE -D_KALEID_KERNEL
#Folders
@ -62,7 +62,7 @@ all : OS/K
# Common objects
kal_com_obj= $(KOBJDIR)/atoi.o $(KOBJDIR)/ctype.o \
$(KOBJDIR)/itoa.o $(KOBJDIR)/memory.o \
$(KOBJDIR)/itoa.o $(KOBJDIR)/mem.o \
$(KOBJDIR)/rand.o $(KOBJDIR)/sprintf.o \
$(KOBJDIR)/status.o $(KOBJDIR)/string.o \
$(KOBJDIR)/strtol.o $(KOBJDIR)/argv.o \
@ -98,7 +98,7 @@ $(KOBJDIR)/utoa.o: $(KERNELDIR)/crtlib/itoa.c
$(KOBJDIR)/ultoa.o: $(KERNELDIR)/crtlib/itoa.c
@$(KCC) -D_NEED_ULTOA $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/memory.o: $(KERNELDIR)/crtlib/memory.c
$(KOBJDIR)/mem.o: $(KERNELDIR)/crtlib/mem.c
@$(KCC) -fno-strict-aliasing $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/rand.o: $(KERNELDIR)/crtlib/rand.c
@ -124,10 +124,18 @@ $(KOBJDIR)/prog.o: $(KERNELDIR)/extras/prog.c
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
# Kernel objects
<<<<<<< HEAD
kal_kern_obj= $(KOBJDIR)/kernel/cpuid.o $(KOBJDIR)/kernel/init.o \
$(KOBJDIR)/kernel/table.o $(KOBJDIR)/kernel/cursor.o \
$(KOBJDIR)/kernel/term.o $(KOBJDIR)/kernel/vga.o \
$(KOBJDIR)/kernel/panic.o $(KOBJDIR)/kernel/map.o \
=======
kal_kern_obj= $(KOBJDIR)/kernel/cpuid.o $(KOBJDIR)/kernel/init.o \
$(KOBJDIR)/kernel/table.o $(KOBJDIR)/kernel/cursor.o \
$(KOBJDIR)/kernel/term.o $(KOBJDIR)/kernel/vga.o \
$(KOBJDIR)/kernel/panic.o $(KOBJDIR)/kernel/heap.o \
$(KOBJDIR)/kernel/malloc.o
>>>>>>> BetterTerm
$(KOBJDIR)/kernel/cpuid.o: $(KERNELDIR)/kernel/cpu/cpuid.c
@$(KCC) $< -o $@
@ -150,7 +158,14 @@ $(KOBJDIR)/kernel/vga.o: $(KERNELDIR)/kernel/io/vga.c
$(KOBJDIR)/kernel/panic.o: $(KERNELDIR)/kernel/ke/panic.c
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
<<<<<<< HEAD
$(KOBJDIR)/kernel/map.o: $(KERNELDIR)/kernel/mm/map.c
=======
$(KOBJDIR)/kernel/heap.o: $(KERNELDIR)/kernel/mm/heap.c
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/malloc.o: $(KERNELDIR)/kernel/mm/malloc.c
>>>>>>> BetterTerm
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}

13
ProjectTree
View File

@ -62,11 +62,14 @@
│   ├── atol.o
│   ├── atoul.o
│   ├── atou.o
│   ├── crtlib
│   ├── ctype.o
│   ├── extras
│   ├── itoa.o
│   ├── kernel
│   │   ├── cpuid.o
│   │   ├── cursor.o
│   │   ├── heap.o
│   │   ├── init
│   │   │   ├── init.o
│   │   │   └── table.o
@ -77,12 +80,13 @@
│   │   │   └── vga.o
│   │   ├── ke
│   │   │   └── panic.o
│   │   ├── malloc.o
│   │   ├── panic.o
│   │   ├── table.o
│   │   ├── term.o
│   │   └── vga.o
│   ├── ltoa.o
│   ├── memory.o
│   ├── mem.o
│   ├── prog.o
│   ├── rand.o
│   ├── sprintf.o
@ -99,7 +103,7 @@
│   │   ├── atoi.c
│   │   ├── ctype.c
│   │   ├── itoa.c
│   │   ├── memory.c
│   │   ├── mem.c
│   │   ├── rand.c
│   │   ├── sprintf.c
│   │   ├── status.c
@ -129,6 +133,7 @@
│   │   ├── kernel
│   │   │   ├── base.h
│   │   │   ├── cpu.h
│   │   │   ├── heap.h
│   │   │   ├── iomisc.h
│   │   │   ├── mm.h
│   │   │   ├── panic.h
@ -151,6 +156,8 @@
│   ├── ke
│   │   └── panic.c
│   ├── mm
│   │   ├── heap.c
│   │   └── malloc.c
│   └── proc
│   ├── Makefile
│   └── sched.c
@ -161,4 +168,4 @@
├── qemu.log
└── Readme.md
31 directories, 105 files
33 directories, 110 files

22
kaleid/crtlib/memory.c → kaleid/crtlib/mem.c
View File

@ -23,9 +23,31 @@
//----------------------------------------------------------------------------//
#include <kalbase.h>
#include <extras/malloc.h>
/* DO NOT compile with strict aliasing on */
//------------------------------------------//
// Memory allocation //
//------------------------------------------//
void *malloc(size_t n)
{
void *ptr;
error_t rc;
rc = KalAllocMemory(&ptr, n, 0, 0);
__set_errno(rc);
return ptr;
}
void free(void *ptr)
{
error_t rc = KalFreeMemory(ptr);
(void)rc;
}
//------------------------------------------//
// memset() family //
//------------------------------------------//

10
kaleid/extras/prog.c
View File

@ -47,17 +47,15 @@ const char *KalGetProgVersion(void)
return __progvers;
}
bool KalSetProgVers(const char *vers)
error_t KalSetProgVers(const char *vers)
{
(void)vers;
__set_errno(ENOSYS);
return false;
return ENOSYS;
}
bool KalSetProgName(const char *name)
error_t KalSetProgName(const char *name)
{
(void)name;
__set_errno(ENOSYS);
return false;
return ENOSYS;
}

13
kaleid/include/base/bdefs.h
View File

@ -45,6 +45,19 @@
//------------------------------------------//
#ifndef _NO_UNITS
#define KB (1UL << 10)
#define MB (1UL << 20)
#define GB (1UL << 30)
#define TB (1UL << 40)
#endif
#ifndef _ALIGN_UP
#define _ALIGN_UP(x, s) (((x) + (s) - 1) & (~((s) - 1)))
#endif
//------------------------------------------//
#ifndef __BEGIN_DECLS
#ifdef __cpluplus
# define __EXTERN_C extern "C"

7
kaleid/include/base/crtlib.h
View File

@ -66,7 +66,7 @@ extern error_t __errno;
#define errno __errno
#endif
#define __get_errno(x) error_t x = errno;
#define __get_errno(x) error_t x = errno
#define __set_errno(x) (errno = (x))
#else
@ -183,6 +183,11 @@ unsigned long strtoul(const char *restrict, char **restrict, int);
//------------------------------------------//
void *malloc(size_t) __attribute__((__malloc__));
void free(void *);
//------------------------------------------//
int rand(void);
void srand(unsigned int);

11
kaleid/include/base/errno.h
View File

@ -69,11 +69,14 @@
// Functionality not implemented
#define ENOSYS 38
// Component crashed
#define ECRASH 500
// Address already in use
#define EADDRINUSE 98
// System is panicking
#define EPANIC 600
// Failure (unspecified reason)
#define EFAILED 256
// Alignment error
#define EALIGN 257
//------------------------------------------//

36
kaleid/include/extras/malloc.h
View File

@ -35,16 +35,34 @@ extern "C" {
//------------------------------------------//
//
// ¯\_(ツ)_/¯
//
#ifndef _STDLIB_H
void *malloc(unsigned long);
void free(void *);
#endif
// Flags for KalAllocMemory
enum
{
// Return zeroed-out memory
M_ZEROED = 1,
#define KalAllocMemory malloc
#define KalFreeMemory free
// Crash if allocation fails (ENABLED by default in the kernel)
M_FAILCRASH = 2,
// Do NOT crash if allocation failed (meaningless outside of the kernel)
M_CANFAIL = 4,
};
enum
{
// Default memory allocation alignment (in bytes)
// Asking KalAllocMemory for an alignment of 0
// will cause it to use this value
M_DEFAULT_ALIGNMENT = alignof(QWORD),
// Minimal memory allocation alignment (in bytes)
// Asking KalAllocMemory for an nonzero alignment
// lower than this value will cause a EALIGN error
M_MINIMAL_ALIGNMENT = M_DEFAULT_ALIGNMENT
};
error_t KalAllocMemory(void **ptr, size_t req, int flags, size_t align);
error_t KalFreeMemory(void *ptr);
//------------------------------------------//

4
kaleid/include/extras/prog.h
View File

@ -43,8 +43,8 @@ extern const char *__progvers;
const char *KalGetProgName(void);
const char *KalGetProgVersion(void);
bool KalSetProgVers(const char *);
bool KalSetProgName(const char *);
error_t KalSetProgVers(const char *);
error_t KalSetProgName(const char *);
//------------------------------------------//

1
kaleid/include/kernel/base.h
View File

@ -46,7 +46,6 @@ typedef struct MemoryMap_t MemoryMap_t;
typedef enum ProcState_t ProcState_t;
typedef enum TermColor_t TermColor_t;
typedef enum KernelState_t KernelState_t;
//------------------------------------------//
// Multiprocessor misc. //

13
kaleid/include/kernel/cpu.h
View File

@ -22,8 +22,21 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALKERN_BASE_H
#include <kernel/base.h>
#endif
#ifndef _KALKERN_CPU_H
#define _KALKERN_CPU_H
//------------------------------------------//
#define cpuid(in, a, b, c, d) asm("cpuid" \
: "=a" (a), "=b" (b), "=c" (c), "=d" (d) \
: "a" (in) \
);
//------------------------------------------//
#endif

51
kaleid/include/kernel/heap.h Normal file
View File

@ -0,0 +1,51 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Memory related functions //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALKERN_BASE_H
#include <kernel/base.h>
#endif
#ifndef _KALKERN_MM_H
#define _KALKERN_MM_H
//------------------------------------------//
#define _HEAP_START (4 * MB)
void InitHeap(void);
void LockHeap(void);
void UnlockHeap(void);
size_t GetHeapSize(void);
size_t GetMaxHeapSize(void);
error_t SetMaxHeapSize(size_t);
error_t GrowHeap(size_t);
error_t ShrinkHeap(size_t);
//------------------------------------------//
#endif

1
kaleid/include/kernel/iomisc.h
View File

@ -22,7 +22,6 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALKERN_BASE_H
#include <kernel/base.h>
#endif

2
kaleid/kernel/init/init.c
View File

@ -21,6 +21,7 @@
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <multiboot/multiboot.h>
#include <kernel/term.h>
#include <kernel/panic.h>
@ -44,3 +45,4 @@ noreturn void StartKern(multiboot_info_t *mbInfo, int mbMagic)
KernLog("Yup, we have magic : %x", mbMagic);
CrashSystem(); //yay
}

1
kaleid/kernel/init/table.c
View File

@ -30,4 +30,3 @@ Processor_t cpuTable[NCPUS] = {0};
MemoryMap_t memTab = {0};
Terminal_t *stdOut = 0, *stdDbg = 0;

18
kaleid/kernel/io/term.c
View File

@ -28,7 +28,7 @@ extern void VGA_Init(void);
extern Terminal_t VGA_Terminal;
//
// Initialize standard output
// Initializes standard output
//
void InitTerms(void)
{
@ -43,7 +43,7 @@ void InitTerms(void)
}
//
// Fill terminal with spaces
// Fills terminal with spaces
//
error_t ClearTerm(Terminal_t *term)
{
@ -60,7 +60,7 @@ error_t ClearTerm(Terminal_t *term)
}
//
// Change the color code
// Changes the color code
//
error_t ChTermColor(Terminal_t *term, TermColor_t fgColor, TermColor_t bgColor)
{
@ -81,7 +81,7 @@ error_t ChTermColor(Terminal_t *term, TermColor_t fgColor, TermColor_t bgColor)
}
//
// Write a single character on the terminal
// Writes a single character on the terminal
//
error_t PutOnTerm(Terminal_t *term, char ch)
{
@ -98,7 +98,7 @@ error_t PutOnTerm(Terminal_t *term, char ch)
}
//
// Print string on terminal
// Prints string on terminal
//
error_t PrintOnTerm(Terminal_t *term, const char *str)
{
@ -117,7 +117,7 @@ error_t PrintOnTerm(Terminal_t *term, const char *str)
}
//
// Print formatted string on standard output
// Prints formatted string on standard output
// Prints at most KLOG_MAX_BUFSIZE characters
//
error_t KernLog(const char *fmt, ...)
@ -130,12 +130,12 @@ error_t KernLog(const char *fmt, ...)
vsnprintf(logbuf, KLOG_MAX_BUFSIZE, fmt, ap);
va_end(ap);
return PrintOnTerm(stdOut, logbuf);
return PrintOnTerm(GetStdOut(), logbuf);
}
#ifndef _NO_DEBUG
//
// Print formatted string on debug output
// Prints formatted string on debug output
// Prints at most KLOG_MAX_BUFSIZE characters
//
error_t DebugLog(const char *fmt, ...)
@ -148,7 +148,7 @@ error_t DebugLog(const char *fmt, ...)
vsnprintf(logbuf, KLOG_MAX_BUFSIZE, fmt, ap);
va_end(ap);
return PrintOnTerm(stdDbg, logbuf);
return PrintOnTerm(GetStdDbg(), logbuf);
}
#endif

6
kaleid/kernel/io/vga.c
View File

@ -37,7 +37,7 @@
#define VGA_ComputeEntry(ch, cl) (((ushort)(ch)) | (ushort)(cl) << 8)
//
// Clear terminal
// Clears terminal
//
error_t VGA_ClearTermUnlocked(Terminal_t *term)
{
@ -55,7 +55,7 @@ error_t VGA_ClearTermUnlocked(Terminal_t *term)
}
//
// Write a single character on the terminal
// Writes a single character on the terminal
//
error_t VGA_PutOnTermUnlocked(Terminal_t *term, char ch)
{
@ -106,7 +106,7 @@ error_t VGA_PutOnTermUnlocked(Terminal_t *term, char ch)
}
//
// Print string on terminal
// Prints string on terminal
//
error_t VGA_PrintOnTermUnlocked(Terminal_t *term, const char *str)
{

4
kaleid/kernel/ke/panic.c
View File

@ -37,7 +37,7 @@ noreturn void __assert_handler(const char *msg,
(void)file; (void)line; (void)func;
StartPanic("cpu%d: In function '%s', from %s line %s - assert() failed: '%s'",
StartPanic("cpu%d: In function '%s', from %s line %d - assert() failed: '%s'",
_GetCurCPU(), func, file, line, msg);
}
@ -80,7 +80,9 @@ noreturn void StartPanic(const char *fmt, ...)
//
noreturn void CrashSystem(void)
{
while (1) {
DisableIRQs();
HaltCPU();
}
}

129
kaleid/kernel/mm/heap.c Normal file
View File

@ -0,0 +1,129 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Early and very dumb heap managment //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/heap.h>
// Least address out of the heap
static void *_heap_end;
// Maximal value of the heap
static size_t _heap_max;
// Lock NOT used internally, but used by KalAllocMemory() & co.
static Lock_t _heap_lock = INITLOCK(KLOCK_SPINLOCK);
// Debugging stub
size_t GetAvailZoneSize(void *x) { (void)x; return 8 * MB; }
//
// Initializes heap managment
//
void InitHeap(void)
{
assert(_heap_end == NULL);
_heap_end = (void *)_HEAP_START;
_heap_max = lmin(8 * MB, GetAvailZoneSize((void *)_HEAP_START));
}
//
// Aquires control of the heap's lock
//
void LockHeap(void)
{
AquireLock(&_heap_lock);
}
//
// Releases control of the heap's lock
//
void UnlockHeap(void)
{
ReleaseLock(&_heap_lock);
}
//
// Returns the heap's current size
//
size_t GetHeapSize(void)
{
return (size_t)_heap_end - _HEAP_START;
}
//
// Returns the heap's maximum size
//
size_t GetMaxHeapSize(void)
{
return _heap_max;
}
//
// Changes the heap's maximal size
//
error_t SetMaxHeapSize(size_t new)
{
if (new > GetAvailZoneSize((void *)_HEAP_START)) {
return ENOMEM;
}
if (new < (size_t)_heap_end - _HEAP_START) {
return EADDRINUSE;
}
_heap_max = new;
return EOK;
}
//
// Extends the heap's size
//
error_t GrowHeap(size_t req)
{
assert(req % alignof(QWORD));
if ((size_t)_heap_end + req > _HEAP_START + _heap_max) {
return ENOMEM;
}
_heap_end += req;
return EOK;
}
//
// Reduces the heap's size
//
error_t ShrinkHeap(size_t req)
{
assert(req % alignof(QWORD));
if (req > (size_t)_heap_end - _HEAP_START) {
return EADDRINUSE;
}
_heap_end -= req;
return EOK;
}

70
kaleid/kernel/mm/malloc.c Normal file
View File

@ -0,0 +1,70 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Early and very dumb memory managment //
// //
// //
// Copyright © 2018-2019 The OS/K Team //
// //
// This file is part of OS/K. //
// //
// OS/K is free software: you can redistribute it and/or modify //
// it under the terms of the GNU General Public License as published by //
// the Free Software Foundation, either version 3 of the License, or //
// any later version. //
// //
// OS/K is distributed in the hope that it will be useful, //
// but WITHOUT ANY WARRANTY//without even the implied warranty of //
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the //
// GNU General Public License for more details. //
// //
// You should have received a copy of the GNU General Public License //
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/heap.h>
#include <extras/malloc.h>
error_t KalAllocMemory(void **ptr, size_t req, int flags, size_t align)
{
error_t rc;
size_t brk;
if (align == 0) align = M_DEFAULT_ALIGNMENT;
if (align < M_MINIMAL_ALIGNMENT) {
return EALIGN;
}
LockHeap();
brk = _HEAP_START + GetHeapSize();
req = _ALIGN_UP(req + brk, align) - brk;
rc = GrowHeap(req);
UnlockHeap();
if (rc) {
if ((flags & M_CANFAIL) == 0)
return rc;
StartPanic("Out of memory");
}
if (flags & M_ZEROED) {
memzero(*ptr, req);
}
*ptr = (void *)brk;
return rc;
}
//
// Frees allocated memory
//
error_t KalFreeMemory(void *ptr)
{
(void)ptr;
}