os-k-team/os-k
os-k-team
/
os-k
2
0
Fork 0
Code Issues 1 Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'BetterTerm' 

TOTAL REORGANIZATION
This commit is contained in:
Adrien Bourmault 2019-04-09 14:51:54 +02:00
parent bbed48b301 1a051fc5b4
commit 4fc47b1ad0
57 changed files with 872 additions and 828 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

71
.stylehlp Normal file
View File

@ -0,0 +1,71 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: //
// //
// //
// 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/>. //
//----------------------------------------------------------------------------//
;=----------------------------------------------------------------------------=;
; GNU GPL OS/K ;
; ;
; Desc: ;
; ;
; ;
; 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 ;
; (at your option) 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/>. ;
;=----------------------------------------------------------------------------=;
#=----------------------------------------------------------------------------=#
# GNU GPL OS/K #
# #
# Desc: #
# #
# #
# 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/>. #
#=----------------------------------------------------------------------------=#

23
.stylehlp_asm
View File

@ -1,23 +0,0 @@
;=----------------------------------------------------------------------------=;
; GNU GPL OS/K ;
; ;
; Desc: ;
; ;
; ;
; 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 ;
; (at your option) 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/>. ;
;=----------------------------------------------------------------------------=;

23
.stylehlp_c
View File

@ -1,23 +0,0 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: //
// //
// //
// 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/>. //
//----------------------------------------------------------------------------//

87
Makefile
View File

@ -33,7 +33,7 @@ ASMFLAGS=-f elf64
LDFLAGS=-melf_x86_64
COPTIM=-O2
CWARNS=-Wall -Wextra -Werror=implicit-function-declaration
CINCLUDES=-Ikaleid/include
CINCLUDES=-Iinclude
CFLAGS1=-nostdlib -ffreestanding -mcmodel=large -std=gnu11
CFLAGS2= -c -g -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -fno-strict-aliasing
CFLAGS=$(CFLAGS1) $(CFLAGS2)
@ -42,7 +42,8 @@ KCC=$(CCNAME) $(COPTIM) $(CWARNS) $(CFLAGS) $(CINCLUDES) -D_OSK_SOURCE -D_KALEID
#Folders
MBRDIR=boot/grub
LOADERDIR=boot/loader
KERNELDIR=kaleid
KALEIDDIR=kaleid
INCLUDEDIR=include
OBJDIR=build/obj
KOBJDIR=build/obj/kaleid
LOBJDIR=build/obj/boot
@ -55,7 +56,6 @@ CL2='\033[1;36m'
CL3='\033[0m'
NC='\033[1;37m'
.PHONY: all
all : OS/K
@ -72,55 +72,66 @@ kal_com_obj= $(KOBJDIR)/atoi.o $(KOBJDIR)/ctype.o \
$(KOBJDIR)/utoa.o $(KOBJDIR)/ltoa.o \
$(KOBJDIR)/ultoa.o
$(KOBJDIR)/atoi.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/atoi.o: $(KALEIDDIR)/libc/atoi.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ATOI $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/atol.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/atol.o: $(KALEIDDIR)/libc/atoi.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ATOL $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/atou.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/atou.o: $(KALEIDDIR)/libc/atoi.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ATOU $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/atoul.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/atoul.o: $(KALEIDDIR)/libc/atoi.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ATOUL $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/ctype.o: $(KERNELDIR)/crtlib/ctype.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/ctype.o: $(KALEIDDIR)/libc/ctype.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/itoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/itoa.o: $(KALEIDDIR)/libc/itoa.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ITOA $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/ltoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/ltoa.o: $(KALEIDDIR)/libc/itoa.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_LTOA $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/utoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/utoa.o: $(KALEIDDIR)/libc/itoa.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_UTOA $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/ultoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/ultoa.o: $(KALEIDDIR)/libc/itoa.c $(INCLUDEDIR)/*/*.h
@$(KCC) -D_NEED_ULTOA $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/mem.o: $(KERNELDIR)/crtlib/mem.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/mem.o: $(KALEIDDIR)/libc/mem.c $(INCLUDEDIR)/*/*.h
@$(KCC) -fno-strict-aliasing $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/rand.o: $(KERNELDIR)/crtlib/rand.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/rand.o: $(KALEIDDIR)/libc/rand.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/sprintf.o: $(KERNELDIR)/crtlib/sprintf.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/sprintf.o: $(KALEIDDIR)/libc/sprintf.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/status.o: $(KERNELDIR)/crtlib/status.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/status.o: $(KALEIDDIR)/libc/status.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/string.o: $(KERNELDIR)/crtlib/string.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/string.o: $(KALEIDDIR)/libc/string.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/strtol.o: $(KERNELDIR)/crtlib/strtol.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/strtol.o: $(KALEIDDIR)/libc/strtol.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/argv.o: $(KERNELDIR)/extras/argv.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/argv.o: $(KALEIDDIR)/extras/argv.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/prog.o: $(KERNELDIR)/extras/prog.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/prog.o: $(KALEIDDIR)/extras/prog.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/buf.o: $(KALEIDDIR)/libbuf/buf.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/bput.o: $(KALEIDDIR)/libbuf/bput.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/bprint.o: $(KALEIDDIR)/libbuf/bprint.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
@ -134,51 +145,42 @@ kal_kern_obj= $(KOBJDIR)/kernel/cpuid.o $(KOBJDIR)/kernel/init.o \
$(KOBJDIR)/kernel/bput.o $(KOBJDIR)/kernel/bprint.o \
$(KOBJDIR)/kernel/gdt.o
$(KOBJDIR)/kernel/cpuid.o: $(KERNELDIR)/kernel/cpu/cpuid.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/cpuid.o: $(KALEIDDIR)/kernel/cpu/cpuid.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/idt.o: $(KERNELDIR)/kernel/cpu/idt.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/idt.o: $(KALEIDDIR)/kernel/cpu/idt.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/init.o: $(KERNELDIR)/kernel/init/init.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/init.o: $(KALEIDDIR)/kernel/init/init.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/table.o: $(KERNELDIR)/kernel/init/table.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/table.o: $(KALEIDDIR)/kernel/init/table.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/cursor.o: $(KERNELDIR)/kernel/io/cursor.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/cursor.o: $(KALEIDDIR)/kernel/io/cursor.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/log.o: $(KERNELDIR)/kernel/ke/log.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/log.o: $(KALEIDDIR)/kernel/ke/log.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/vga.o: $(KERNELDIR)/kernel/io/vga.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/vga.o: $(KALEIDDIR)/kernel/io/vga.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/panic.o: $(KERNELDIR)/kernel/ke/panic.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/panic.o: $(KALEIDDIR)/kernel/ke/panic.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/map.o: $(KERNELDIR)/kernel/mm/map.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/map.o: $(KALEIDDIR)/kernel/mm/map.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/heap.o: $(KERNELDIR)/kernel/mm/heap.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/heap.o: $(KALEIDDIR)/kernel/mm/heap.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/malloc.o: $(KERNELDIR)/kernel/mm/malloc.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/malloc.o: $(KALEIDDIR)/kernel/mm/malloc.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
$(KOBJDIR)/kernel/gdt.o: $(KERNELDIR)/kernel/mm/gdt.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/gdt.o: $(KALEIDDIR)/kernel/mm/gdt.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/buf.o: $(KERNELDIR)/kernel/buf/buf.c $(KERNELDIR)/include/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/bput.o: $(KERNELDIR)/kernel/buf/bput.c $(KERNELDIR)/include/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/bprint.o: $(KERNELDIR)/kernel/buf/bprint.c $(KERNELDIR)/include/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
$(KOBJDIR)/kernel/sched.o: $(KERNELDIR)/kernel/proc/sched.c $(KERNELDIR)/include/*/*.h
$(KOBJDIR)/kernel/sched.o: $(KALEIDDIR)/kernel/ps/sched.c $(INCLUDEDIR)/*/*.h
@$(KCC) $< -o $@
@echo ${CL2}[$@] ${CL}Compiled.${CL3}
@ -189,6 +191,7 @@ $(KOBJDIR)/kernel/sched.o: $(KERNELDIR)/kernel/proc/sched.c $(KERNELDIR)/include
@echo "\n" >> ./ProjectTree
@tree --dirsfirst >> ./ProjectTree
@echo ${CL2}[$@] ${CL}Generated.${CL3}
## MAIN MAKEFILE ------------------------------------------------------------- #
.PHONY: test

136
ProjectTree
View File

@ -89,82 +89,82 @@
│   │   ├── ultoa.o
│   │   └── utoa.o
│   ├── grub.log
│   └── kernel.ld
│   ├── kernel.ld
│   └── qemu.log
├── include
│   ├── base
│   │   ├── assert.h
│   │   ├── bdefs.h
│   │   ├── crtlib.h
│   │   ├── errno.h
│   │   ├── limits.h
│   │   ├── masks.h
│   │   └── types.h
│   ├── extras
│   │   ├── argv.h
│   │   ├── buf.h
│   │   ├── list.h
│   │   ├── locks.h
│   │   ├── malloc.h
│   │   └── prog.h
│   ├── kernel
│   │   ├── base.h
│   │   ├── boot.h
│   │   ├── cpu.h
│   │   ├── heap.h
│   │   ├── iomisc.h
│   │   ├── mboot.h
│   │   ├── mm.h
│   │   ├── panic.h
│   │   ├── proc.h
│   │   └── sched.h
│   ├── kalbase.h
│   ├── kaleid.h
│   └── kalext.h
├── kaleid
│   ├── crtlib
│   │   ├── atoi.c
│   │   ├── ctype.c
│   │   ├── itoa.c
│   │   ├── mem.c
│   │   ├── rand.c
│   │   ├── sprintf.c
│   │   ├── status.c
│   │   ├── string.c
│   │   └── strtol.c
│   ├── extras
│   │   ├── argv.c
│   │   └── prog.c
│   ├── include
│   │   ├── base
│   │   │   ├── assert.h
│   │   │   ├── bdefs.h
│   │   │   ├── crtlib.h
│   │   │   ├── errno.h
│   │   │   ├── limits.h
│   │   │   ├── masks.h
│   │   │   └── types.h
│   │   ├── extras
│   │   │   ├── argv.h
│   │   │   ├── list.h
│   │   │   ├── locks.h
│   │   │   ├── malloc.h
│   │   │   └── prog.h
│   │   ├── kernel
│   │   │   ├── base.h
│   │   │   ├── buf.h
│   │   │   ├── cpu.h
│   │   │   ├── heap.h
│   │   │   ├── iomisc.h
│   │   │   ├── log.h
│   │   │   ├── mboot.h
│   │   │   ├── mm.h
│   │   │   ├── panic.h
│   │   │   ├── proc.h
│   │   │   └── sched.h
│   │   ├── kalbase.h
│   │   ├── kaleid.h
│   │   └── kalext.h
│   └── kernel
│   ├── buf
│   │   ├── bprint.c
│   │   ├── bput.c
│   │   └── buf.c
│   ├── cpu
│   │   ├── cpuid.c
│   │   └── idt.c
│   ├── init
│   │   ├── init.c
│   │   └── table.c
│   ├── io
│   │   ├── ata.inc
│   │   ├── cursor.c
│   │   └── vga.c
│   ├── ke
│   │   ├── log.c
│   │   └── panic.c
│   ├── mm
│   │   ├── gdt.c
│   │   ├── heap.c
│   │   ├── malloc.c
│   │   └── map.c
│   └── proc
│   ├── Makefile
│   └── sched.c
│   ├── kernel
│   │   ├── cpu
│   │   │   ├── cpuid.c
│   │   │   └── idt.c
│   │   ├── init
│   │   │   ├── init.c
│   │   │   └── table.c
│   │   ├── io
│   │   │   ├── ata.inc
│   │   │   ├── cursor.c
│   │   │   └── vga.c
│   │   ├── ke
│   │   │   ├── log.c
│   │   │   └── panic.c
│   │   ├── mm
│   │   │   ├── gdt.c
│   │   │   ├── heap.c
│   │   │   ├── malloc.c
│   │   │   └── map.c
│   │   └── ps
│   │   └── sched.c
│   ├── libbuf
│   │   ├── bprint.c
│   │   ├── bput.c
│   │   └── buf.c
│   └── libc
│   ├── atoi.c
│   ├── ctype.c
│   ├── itoa.c
│   ├── mem.c
│   ├── rand.c
│   ├── sprintf.c
│   ├── status.c
│   ├── string.c
│   └── strtol.c
├── AUTHORS
├── ChangeLog
├── COPYING
├── Makefile
├── ProjectTree
└── Readme.md
└── README.md
28 directories, 114 files

5
Readme.md → README.md
View File

@ -14,6 +14,8 @@ For structure of the sources, see [ProjectTree](ProjectTree)
Note that every file within OS/K is written using spaces for tabulation, with each
tabulation being 4 spaces long.
IRC Channel: #os.k-devel on Freenode
#### Compile from sources
To compile this project from sources, you must first install the dependencies
@ -23,7 +25,7 @@ apt update && apt upgrade
apt install grub-pc dosfstools make nasm qemu
```
You also need to have the [x86-64 ELF gcc cross-compiler](https://www.os-k.eu/build-tools/cross-cc.tar.xz) in `/opt/cross-cc`.
You also need to have the [x86-64 ELF gcc cross-compiler](https://www.os-k.eu/build-tools/cross-cc.tar.xz) and its "bin" repertory in your PATH.
To compile, simply use at the root of this project :
```
@ -34,3 +36,4 @@ To compile and test, simply use at the root of this project :
```
make test
```

2
boot/grub/grub.cfg
View File

@ -22,7 +22,7 @@
# along with OS/K. If not, see <https://www.gnu.org/licenses/>. #
#=----------------------------------------------------------------------------=#
set timeout=5
set timeout=0
set default=0 #Set the default menu entry

0
kaleid/include/base/assert.h → include/base/assert.h
View File

0
kaleid/include/base/bdefs.h → include/base/bdefs.h
View File

0
kaleid/include/base/crtlib.h → include/base/crtlib.h
View File

0
kaleid/include/base/errno.h → include/base/errno.h
View File

0
kaleid/include/base/limits.h → include/base/limits.h
View File

0
kaleid/include/base/masks.h → include/base/masks.h
View File

0
kaleid/include/base/types.h → include/base/types.h
View File

0
kaleid/include/extras/argv.h → include/extras/argv.h
View File

9
kaleid/include/kernel/buf.h → include/extras/buf.h
View File

@ -22,12 +22,12 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALKERN_BASE_H
#include <kernel/base.h>
#ifndef _KALEXTRAS_LOCKS_H
#include <extras/locks.h>
#endif
#ifndef _KALKERN_BUF_H
#define _KALKERN_BUF_H
#ifndef _KALEXTRAS_BUF_H
#define _KALEXTRAS_BUF_H
//
// Buffer flags
@ -55,6 +55,7 @@ enum
BS_WRONLY, // Only for writing
};
typedef struct Buffer_t Buffer_t;
typedef error_t (*BFlusher_t)(Buffer_t *);
struct Buffer_t

0
kaleid/include/extras/list.h → include/extras/list.h
View File

0
kaleid/include/extras/locks.h → include/extras/locks.h
View File

9
kaleid/include/extras/malloc.h → include/extras/malloc.h
View File

@ -35,7 +35,7 @@ extern "C" {
//------------------------------------------//
// Flags for KalAllocMemory
// Flags for KalAllocMemoryEx
enum
{
// Return zeroed-out memory
@ -51,17 +51,18 @@ enum
enum
{
// Default memory allocation alignment (in bytes)
// Asking KalAllocMemory for an alignment of 0
// Asking KalAllocMemoryEx 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
// Asking KalAllocMemoryEx 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 KalAllocMemoryEx(void **ptr, size_t req, int flags, size_t align);
error_t KalAllocMemory(void **ptr, size_t req);
error_t KalFreeMemory(void *ptr);
//------------------------------------------//

0
kaleid/include/extras/prog.h → include/extras/prog.h
View File

0
kaleid/include/kalbase.h → include/kalbase.h
View File

0
kaleid/include/kaleid.h → include/kaleid.h
View File

0
kaleid/include/kalext.h → include/kalext.h
View File

137
include/kernel/base.h Normal file
View File

@ -0,0 +1,137 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Kaleid kernel base include file //
// //
// //
// 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 _KALBASE_H
#include <kalbase.h>
#endif
#ifdef __cplusplus
#error "Kaleid's kernel won't compile in C++"
#endif
#ifndef _KALKERN_BASE_H
#define _KALKERN_BASE_H
//------------------------------------------//
typedef struct Lock_t Lock_t;
typedef struct Buffer_t Buffer_t;
typedef struct Thread_t Thread_t;
typedef struct Process_t Process_t;
typedef struct BootInfo_t BootInfo_t;
typedef struct ListHead_t ListHead_t;
typedef struct ListNode_t ListNode_t;
typedef struct Processor_t Processor_t;
typedef enum ProcState_t ProcState_t;
//------------------------------------------//
//
// Holds all CPU-local variables
//
struct Processor_t
{
// CPU number, index in CPU list
int index;
// CPU APIC id
int apicId;
// CPU Vendor String (always 12 characters)
char vendorStr[12];
// CPU Model code (enum in cpu.h)
int modelCode;
// CPU Features flag
uint featureFlag;
// Number of ticks since boot time
ulong ticks;
// Current process & thread
Process_t *process;
Thread_t *thread;
// Need re-schedule?
bool needReSched;
// Is preemption ON? ("PREEMPT_ON" in sched.h)
ulong preemptCount;
// List heads for the four priority classes
ListHead_t *idlePrioProcs;
ListHead_t *reglPrioProcs;
ListHead_t *servPrioProcs;
ListHead_t *timeCritProcs;
};
//------------------------------------------//
#ifndef NCPUS
#define NCPUS 1
#endif
// Current CPU number
#define _KeCurCPU 0
extern int KeCPUCount;
extern volatile Processor_t *KeCurCPU;
extern Processor_t _KeCPUTable[NCPUS];
//------------------------------------------//
#define DEC_PER_CPU(pref, name, field, type) \
static inline type pref##Get##name() { return KeGetCurCPU()->field; } \
static inline void _##pref##Set##name(type __val) \
{ KeGetCurCPU()->field = __val; }
#define BARRIER() \
do { \
asm volatile("": : :"memory"); \
__sync_synchronize(); \
} while(0)
//------------------------------------------//
error_t KernLog(const char *, ...);
#ifndef _NO_DEBUG
void DebugLog(const char *, ...);
#else
#define DebugLog(fmt, ...) ((void)0)
#endif
//------------------------------------------//
// Needed by basically everyone
#ifndef _KALEXTRAS_LOCKS_H
#include <extras/locks.h>
#endif
//------------------------------------------//
#endif

107
kaleid/include/kernel/base.h → include/kernel/boot.h
View File

@ -22,88 +22,15 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#ifndef _KALBASE_H
#include <kalbase.h>
#endif
#ifdef __cplusplus
#error "Kaleid's kernel won't compile in C++"
#endif
#ifndef _KALKERN_BASE_H
#define _KALKERN_BASE_H
//------------------------------------------//
typedef struct Lock_t Lock_t;
typedef struct Buffer_t Buffer_t;
typedef struct Thread_t Thread_t;
typedef struct Process_t Process_t;
typedef struct Terminal_t Terminal_t;
typedef struct ListHead_t ListHead_t;
typedef struct ListNode_t ListNode_t;
typedef struct Processor_t Processor_t;
typedef struct BootInfo_t BootInfo_t;
typedef enum ProcState_t ProcState_t;
typedef enum TermColor_t TermColor_t;
//------------------------------------------//
// Multiprocessor misc. //
//------------------------------------------//
#ifndef NCPUS
#define NCPUS 1
#include <kernel/base.h>
#endif
// Current CPU number
#define _KeCurCPU 0
// Process_t structure of current CPU
#define KeCurCPU (cpuTable[_KeCurCPU])
// Access the BootInfo_t structure
#define BtGetBootInfo(x) (bootTab.x)
#ifndef _KALKERN_BOOT_H
#define _KALKERN_BOOT_H
//------------------------------------------//
//
// Holds all CPU-local variables
//
struct Processor_t
{
// CPU number, index in CPU list
int index;
// CPU APIC id
int apicId;
// CPU Vendor String (always 12 characters)
char vendorStr[12];
// CPU Model code (enum in cpu.h)
int modelCode;
// CPU Features flag
uint featureFlag;
// Number of ticks since boot time
ulong ticks;
// Current process & thread
Process_t *process;
Thread_t *thread;
// Need re-schedule?
bool needReSched;
// Is preemption ON? ("PREEMPT_ON" in sched.h)
ulong preemptCount;
// List heads for the four priority classes
ListHead_t *idlePrioProcs;
ListHead_t *reglPrioProcs;
ListHead_t *servPrioProcs;
ListHead_t *timeCritProcs;
};
#define FB_EGA_TEXT 2
#define FB_INDEXED 0
#define FB_RGB 1
@ -111,7 +38,7 @@ struct Processor_t
struct BootInfo_t
{
// The Bootloader infos (GRUB in our case)
// The Bootloader infos
struct {
ushort valid;
uint grubFlags; //flags
@ -176,28 +103,14 @@ struct BootInfo_t
//------------------------------------------//
extern volatile int cpuCount;
extern volatile BootInfo_t bootTab;
extern volatile Processor_t cpuTable[NCPUS];
extern volatile BootInfo_t BtBootTab;
//------------------------------------------//
#define DEC_PER_CPU(pref, name, field, type) \
static inline type pref##Get##name() { return KeGetCurCPU().field; } \
static inline void _##pref##Set##name(type __val) \
{ KeGetCurCPU().field = __val; }
#define BARRIER() do{\
asm volatile("": : :"memory");__sync_synchronize();}while(0)
//------------------------------------------//
// Needed by basically everyone
#ifndef _KALEXTRAS_LOCKS_H
#include <extras/locks.h>
#endif
#define BtLoaderInfo (BtBootTab.btldr)
#define BtDrivesInfo (BtBootTab.drives)
#define BtMemoryInfo (BtBootTab.memory)
#define BtVideoInfo (BtBootTab.video)
#define BtFirmwareInfo (BtBootTab.firmware)
//------------------------------------------//
#endif

0
kaleid/include/kernel/cpu.h → include/kernel/cpu.h
View File

0
kaleid/include/kernel/heap.h → include/kernel/heap.h
View File

0
kaleid/include/kernel/iomisc.h → include/kernel/iomisc.h
View File

0
kaleid/include/kernel/mboot.h → include/kernel/mboot.h
View File

4
kaleid/include/kernel/mm.h → include/kernel/mm.h
View File

@ -66,7 +66,7 @@ struct GdtEntry_t
uchar access; // determine what ring this segment can be used in
uchar granularity;
uchar highBase; // last 8 bits
} __attribute__((packed));
} __attribute__((__packed__));
// The gdt pointer
struct GdtPtr_t
@ -74,7 +74,7 @@ struct GdtPtr_t
uchar limit; // upper 16 bits
ushort base; // address of the first entry
}
__attribute__((packed));
__attribute__((__packed__));
// -------------------------------------------------------------------------- //

2
kaleid/include/kernel/panic.h → include/kernel/panic.h
View File

@ -32,7 +32,7 @@
//------------------------------------------//
#define PANICSTR_SIZE 1024
extern volatile char KePanicStr[PANICSTR_SIZE];
extern volatile bool KeIsPanicking;
//------------------------------------------//

7
kaleid/include/kernel/proc.h → include/kernel/proc.h
View File

@ -70,15 +70,12 @@ struct Process_t
// Scheduler internals
ListNode_t *schedNode;
// Standard output/debug
Terminal_t *stdOut, *stdDbg;
};
//------------------------------------------//
#define PsCurProc (KeCurCPU.process)
#define PsCurThread (KeCurCPU.thread)
#define PsCurProc (KeCurCPU->process)
#define PsCurThread (KeCurCPU->thread)
//DEC_PER_CPU(Ps, CurProc, process, Process_t *);
//DEC_PER_CPU(Ps, CurThread, thread, Thread_t *);

8
kaleid/include/kernel/sched.h → include/kernel/sched.h
View File

@ -61,10 +61,10 @@ extern const char *PsPrioClassesNames[];
// Re-scheduling and preemption
// XXX atomic operations
//
#define PsRequestReSched() (++KeCurCPU.needReSched)
#define PsDisablePreemption() (++KeCurCPU.preemptCount)
#define PsEnablePreemption() do { assert(KeCurCPU.preemptCount > 0); \
--KeCurCPU.preemptCount; } while(0)
#define PsRequestReSched() (++KeCurCPU->needReSched)
#define PsDisablePreemption() (++KeCurCPU->preemptCount)
#define PsEnablePreemption() do { assert(KeCurCPU->preemptCount > 0); \
--KeCurCPU->preemptCount; } while(0)
//------------------------------------------//

40
kaleid/include/kernel/log.h
View File

@ -1,40 +0,0 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: KernLog() and DebugLog() //
// //
// //
// 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_LOG_H
#define _KALKERN_LOG_H
error_t KernLog(const char *, ...);
#ifndef _NO_DEBUG
void DebugLog(const char *, ...);
#else // _NO_DEBUG
#define DebugLog(fmt, ...)
#endif
#endif

373
kaleid/kernel/buf/bprint.c
View File

@ -1,373 +0,0 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// 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/buf.h>
extern error_t bputc(Buffer_t *buf, uchar ch);
//
// Prints formatted string on buf according to fmt
//
error_t BPrintOnBuf(Buffer_t *buf, const char *fmt, ...)
{
error_t rc;
va_list ap;
va_start(ap, fmt);
rc = BPrintOnBufV(buf, fmt, ap);
va_end(ap);
return rc;
}
//
// Prints 0 for octal, 0x for hexadecimal, 0b for binary
//
static error_t bprinthash(Buffer_t *buf, int base, int cap)
{
error_t rc;
if (base != 2 && base != 8 && base != 16) {
return EOK;
}
rc = bputc(buf, '0');
if (!rc && base != 8) {
rc = bputc(buf, (base==2 ? 'b' : (cap ? 'X' : 'x')));
}
return rc;
}
static error_t bdopadding(Buffer_t *buf, size_t width, size_t len,
char filler)
{
error_t rc = EOK;
for (; !rc && width > len ; width--) {
rc = bputc(buf, filler);
}
return rc;
}
#define bdoconvrt(pref, type, vtype) do { \
type i_##type = (type)va_arg(ap, vtype); \
pref##toa(i_##type, s, base); \
} while (0)
// Increase fmt while parsing a modifier
#define fmtnext() do{fmt++;if(*fmt==0){rc=EINVAL;goto leave;}}while(0)
//
// Actually does BPrintOnBuf's job
// Quite a long function
//
error_t BPrintOnBufV(Buffer_t *buf, const char *fmt, va_list ap)
{
error_t rc = EOK;
int tmpwidth;
size_t width;
char type;
uchar uch;
char *s;
// Conversion buffer
char convbuf[100];
size_t len;
// Flags
int plus, minus, space, zero, hash;
// Length modifiers
int l, h, hh;
// Signed
bool sgn;
// Capital digits
bool cap;
// Base
int base;
assert(buf && buf->initDone == INITOK);
if (!buf) return EINVAL;
if (buf->state != BS_RDWR && buf->state != BS_WRONLY) {
return EBADF;
}
ExAcquireLock(&buf->lock);
//----------------------------------------------------------------------------//
// We come back here after dealing with a modifier
loop:
// Deal with all non-'%' characters
for (; *fmt && *fmt != '%' ; fmt++) {
rc = bputc(buf, *fmt);
continue;
}
// Job's done / something bad happened
if (rc || !*fmt) goto leave;
//----------------------------------------------------------------------------//
//
// %[parameter][flags][width|*][.precision][length]type
// We aren't dealing with parameters and float stuff just yet
//
// Skip the '%'
fmtnext();
// "%%" modifier
if (*fmt == '%') {
rc = bputc(buf, '%');
if (rc > 0) goto leave;
else {
fmt++;
goto loop;
}
}
// Reset everything
width = 0;
cap = sgn = 0;
l = h = hh = 0;
plus = minus = space = zero = hash = 0;
//----------------------------------------------------------------------------//
//
// Flags field
//
while (1) {
if (*fmt == '#') hash++;
else if (*fmt == '0') zero++;
else if (*fmt == '+') plus++;
else if (*fmt == '-') minus++;
else if (*fmt == ' ') space++;
else break;
fmtnext();
}
//----------------------------------------------------------------------------//
//
// Width field
// A width field of zero is ignored
//
// '*' means we should extract it from the argument list
if (*fmt == '*') {
fmtnext();
tmpwidth = va_arg(ap, int);
// A width below 0 activates the "minus" flag
if (tmpwidth < 0) {
width = -tmpwidth;
minus++;
} else {
width = tmpwidth;
}
} else {
// Extract width field from fmt
while (isdigit(*fmt) && width < sizeof(convbuf)-10) {
width = 10 * width + (*fmt - '0');
fmtnext();
}
}
if (width > sizeof(convbuf)) {
rc = EINVAL;
goto leave;
}
//----------------------------------------------------------------------------//
//
// Precision field
// Ignored until floats are implemented
// TODO before floats: %.XXXs
//
//----------------------------------------------------------------------------//
//
// Length field
//
while (1) {
if (*fmt == 'l' || *fmt == 'z') l++;
else if (*fmt == 'h') h++;
else break;
fmtnext();
}
// Consistency check
assert(!(l > 0 && h > 0));
assert(!(l > 2 || h > 2));
//----------------------------------------------------------------------------//
//
// The type field
//
type = *fmt++;
// Characters
if (type == 'c') {
uch = (uchar)va_arg(ap, int);
bputc(buf, uch);
goto loop;
}
// Strings
else if (type == 's') {
s = va_arg(ap, char *);
if (s == NULL) s = "(null)";
for (; !rc && *s ; s++) {
rc = bputc(buf, (uchar)*s);
}
if (rc > 0) goto leave;
goto loop;
}
// Decimal, unsigned decimal, hexadecimal, octal and binary numbers
else if (type == 'd' || type == 'i') { base = 10; sgn = 1; }
else if (type == 'X') { base = 16; cap = 1; }
else if (type == 'x') { base = 16; }
else if (type == 'u') { base = 10; }
else if (type == 'o') { base = 8; }
else if (type == 'b') { base = 2; }
// Pointers: %p = %#012x
// (48-bit pointers have width 12 at least)
else if (type == 'p') {
type = 'x'; base = 16; zero++; hash++; l++;
if (width < 12) width = 12;
}
// Unknown/unsupported modifier
else {
rc = EINVAL;
goto leave;
}
//----------------------------------------------------------------------------//
//
// Numerical conversions
//
// We re-use s to iterate convbuf
s = convbuf;
if (!l) {
if (sgn) {
if (h == 0) bdoconvrt(i, int, int);
if (h == 1) bdoconvrt(i, short, int);
if (h == 2) bdoconvrt(i, char, int);
} else {
if (h == 0) bdoconvrt(u, uint, uint);
if (h == 1) bdoconvrt(u, ushort, uint);
if (h == 2) bdoconvrt(u, uchar, uint);
}
}
else {
if (sgn) bdoconvrt(l, long, long);
else bdoconvrt(ul, ulong, ulong);
}
//----------------------------------------------------------------------------//
//
// Implement flags and %X, and prints
//
// Capital letter digits
if (base > 10 && cap) {
for (; *s ; s++)
if (islower(*s)) *s = toupper(*s);
// We use this "opportunity" to compute the length of s
len = s - convbuf;
// Reset s
s = convbuf;
}
else len = strlen(s);
// Adjust width
if (sgn && (plus || space)) width--;
else if (hash) width -= (base==8 ? 1 : ((base==2||base==16) ? 2 : 0));
// When padding with spaces, we pad before +/-'s etc
if (!minus && !zero && width > len)
bdopadding(buf, width, len, ' ');
// Deal with signs and the hash flag
if (*s == '-') { rc = bputc(buf, '-'); s++, len--; }
else if (sgn && plus) rc = bputc(buf, '+');
else if (sgn && space) rc = bputc(buf, ' ');
else bprinthash(buf, base, cap);
// Deal with padding by zeroes
// The 'minus' flag makes no sense with the 'zero' one
if (zero && width > len)
bdopadding(buf, width, len, '0');
//
// Output the actual number
//
for (; !rc && *s ; s++) {
rc = bputc(buf, (uchar)*s);
}
// 'minus' padding, only with spaces
if (minus && !zero && width > len)
bdopadding(buf, width, base, ' ');
if (rc > 0) goto leave;
// Continue parsing fmt
goto loop;
//----------------------------------------------------------------------------//
leave:
ExReleaseLock(&buf->lock);
return rc;
}

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

@ -26,11 +26,9 @@
#include <kernel/panic.h>
#include <kernel/sched.h>
#include <kernel/heap.h>
#include <kernel/buf.h>
#include <kernel/log.h>
#include <kernel/boot.h>
#include <kernel/mm.h>
//
// BootInfo_t initialization. It is necessary because grub will potentially be
// wiped since it is below 1MB.... And we must reorganize all that stuff.
@ -44,69 +42,69 @@ void BtInitBootInfo(multiboot_info_t *mbi)
KalAlwaysAssert(mbi);
//Retrieves the bootloader flags to ensure infos are valid
BtGetBootInfo(btldr).grubFlags = mbi->flags;
BtLoaderInfo.grubFlags = mbi->flags;
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_BOOT_LOADER_NAME) {
BtGetBootInfo(btldr).grubName = (char*)(ulong)(mbi->boot_loader_name);
BtGetBootInfo(btldr).kernelAddr = (void*)&MB_header;
BtGetBootInfo(btldr).kernelEndAddr = (void*)newKernelEnd;
BtGetBootInfo(btldr).valid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_BOOT_LOADER_NAME) {
BtLoaderInfo.grubName = (char*)(ulong)(mbi->boot_loader_name);
BtLoaderInfo.kernelAddr = (void*)&MB_header;
BtLoaderInfo.kernelEndAddr = (void*)newKernelEnd;
BtLoaderInfo.valid = 1;
}
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_MODS) {
BtGetBootInfo(btldr).modulesCount = mbi->mods_count;
BtGetBootInfo(btldr).modulesAddr = (void*)(ulong)mbi->mods_addr;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_MODS) {
BtLoaderInfo.modulesCount = mbi->mods_count;
BtLoaderInfo.modulesAddr = (void*)(ulong)mbi->mods_addr;
}
//Retrieves the drives informations
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_DRIVE_INFO) {
BtGetBootInfo(drives).bufferLength = mbi->drives_length;
BtGetBootInfo(drives).bufferAddr = (void*)(ulong)mbi->drives_addr;
BtGetBootInfo(drives).bufferValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_DRIVE_INFO) {
BtBootTab.drives.bufferLength = mbi->drives_length;
BtBootTab.drives.bufferAddr = (void*)(ulong)mbi->drives_addr;
BtBootTab.drives.bufferValid = 1;
}
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_BOOTDEV) {
BtGetBootInfo(drives).bootDrv = mbi->boot_device;
BtGetBootInfo(drives).drvValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_BOOTDEV) {
BtBootTab.drives.bootDrv = mbi->boot_device;
BtBootTab.drives.drvValid = 1;
}
//Retrieves the memory informations
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_MEMORY) {
BtGetBootInfo(memory).lowMemory = mbi->mem_lower;
BtGetBootInfo(memory).upMemory = mbi->mem_upper;
BtGetBootInfo(memory).memValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_MEMORY) {
BtMemoryInfo.lowMemory = mbi->mem_lower;
BtMemoryInfo.upMemory = mbi->mem_upper;
BtMemoryInfo.memValid = 1;
}
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_MEM_MAP) {
BtGetBootInfo(memory).mapAddr = (void*)(ulong)mbi->mmap_addr;
BtGetBootInfo(memory).mapLength = mbi->mmap_length;
BtGetBootInfo(memory).mapValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_MEM_MAP) {
BtMemoryInfo.mapAddr = (void*)(ulong)mbi->mmap_addr;
BtMemoryInfo.mapLength = mbi->mmap_length;
BtMemoryInfo.mapValid = 1;
}
// Retrieves video mode informations
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_VBE_INFO) {
BtGetBootInfo(video).vbeControl = (void*)(ulong)mbi->vbe_control_info;
BtGetBootInfo(video).vbeModeInfo = (void*)(ulong)mbi->vbe_mode_info;
BtGetBootInfo(video).vbeMode = mbi->vbe_mode;
BtGetBootInfo(video).vbeInterfaceSeg = mbi->vbe_interface_seg;
BtGetBootInfo(video).vbeInterfaceOff = mbi->vbe_interface_off;
BtGetBootInfo(video).vbeInterfaceLen = mbi->vbe_interface_len;
BtGetBootInfo(video).vbeValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_VBE_INFO) {
BtVideoInfo.vbeControl = (void*)(ulong)mbi->vbe_control_info;
BtVideoInfo.vbeModeInfo = (void*)(ulong)mbi->vbe_mode_info;
BtVideoInfo.vbeMode = mbi->vbe_mode;
BtVideoInfo.vbeInterfaceSeg = mbi->vbe_interface_seg;
BtVideoInfo.vbeInterfaceOff = mbi->vbe_interface_off;
BtVideoInfo.vbeInterfaceLen = mbi->vbe_interface_len;
BtVideoInfo.vbeValid = 1;
}
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_FRAMEBUFFER_INFO) {
BtGetBootInfo(video).framebufferAddr = (void*)mbi->framebuffer_addr;
BtGetBootInfo(video).framebufferPitch = mbi->framebuffer_pitch;
BtGetBootInfo(video).framebufferWidth = mbi->framebuffer_width;
BtGetBootInfo(video).framebufferHeight= mbi->framebuffer_height;
BtGetBootInfo(video).framebufferBpp = mbi->framebuffer_bpp;
BtGetBootInfo(video).framebufferType = mbi->framebuffer_type;
BtGetBootInfo(video).fbuValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_FRAMEBUFFER_INFO) {
BtVideoInfo.framebufferAddr = (void*)mbi->framebuffer_addr;
BtVideoInfo.framebufferPitch = mbi->framebuffer_pitch;
BtVideoInfo.framebufferWidth = mbi->framebuffer_width;
BtVideoInfo.framebufferHeight= mbi->framebuffer_height;
BtVideoInfo.framebufferBpp = mbi->framebuffer_bpp;
BtVideoInfo.framebufferType = mbi->framebuffer_type;
BtVideoInfo.fbuValid = 1;
}
// Retrieves the firmware infos
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_CONFIG_TABLE) {
BtGetBootInfo(firmware).romTable = mbi->config_table;
BtGetBootInfo(firmware).romValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_CONFIG_TABLE) {
BtFirmwareInfo.romTable = mbi->config_table;
BtFirmwareInfo.romValid = 1;
}
if (BtGetBootInfo(btldr).grubFlags & MULTIBOOT_INFO_APM_TABLE) {
BtGetBootInfo(firmware).apmTable = mbi->apm_table;
BtGetBootInfo(firmware).apmValid = 1;
if (BtLoaderInfo.grubFlags & MULTIBOOT_INFO_APM_TABLE) {
BtFirmwareInfo.apmTable = mbi->apm_table;
BtFirmwareInfo.apmValid = 1;
}
}
@ -118,11 +116,11 @@ void BtInitSanity(uint mbMagic){
if (!(mbMagic == MULTIBOOT_BOOTLOADER_MAGIC))
KeStartPanic("[Init] Magic number %x is incorrect\n", mbMagic);
tmp = (BtGetBootInfo(btldr).kernelEndAddr
- BtGetBootInfo(btldr).kernelAddr) / KB;
tmp = (BtLoaderInfo.kernelEndAddr
- BtLoaderInfo.kernelAddr) / KB;
DebugLog("[Init] Kernel successfully loaded at %p with %x magic\n"
" and it uses %d Kio\n\n",
BtGetBootInfo(btldr).kernelAddr,
BtLoaderInfo.kernelAddr,
mbMagic,tmp);
}
@ -141,24 +139,19 @@ noreturn void BtStartKern(multiboot_info_t *mbInfo, uint mbMagic)
// Initialize the BootInfo_t structure
BtInitBootInfo(mbInfo);
// Get ready to print things
// Screen I/O available from this point on
IoInitVGABuffer();
// Sanity checks and hello world
BtInitSanity(mbMagic);
//Memory mapping
// Memory & scheduler
MmInitMemoryMap();
MmInitHeap();
//int i = 0;
//while(i < 512) { KernLog("%d\n", i++);}
//MmPrintMemoryMap();
PsInitSched();
// We're out
PsFiniSched();
KeCrashSystem(); //yay
KeStartPanic("Test Panic %d", 4);
// End this machine's suffering
KeCrashSystem();
}

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

@ -22,13 +22,12 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/base.h>
#include <kernel/boot.h>
volatile int cpuCount = 1;
volatile Processor_t cpuTable[NCPUS] = {0};
int KeCPUCount = 1;
Processor_t _KeCPUTable[NCPUS] = {0};
volatile BootInfo_t bootTab = {0};
Terminal_t *StdOut = 0, *StdDbg = 0;
volatile char KePanicStr[PANICSTR_SIZE] = {0};
volatile BootInfo_t BtBootTab = {0};
volatile bool KeIsPanicking = 0;
volatile Processor_t *KeCurCPU = &_KeCPUTable[0];

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

@ -22,7 +22,8 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/buf.h>
#include <extras/buf.h>
#include <kernel/boot.h>
//----------------------------------------------------------//
// Internal functions for VGA terminals //
@ -41,12 +42,10 @@
//
error_t bvgaflusher(Buffer_t *buf)
{
ushort *fbp = BtGetBootInfo(video).framebufferAddr;
ushort *fbp = BtVideoInfo.framebufferAddr;
const uchar color = 0xf;
assert(buf->lastLF == 0);
uchar *currentLine = buf->wp - buf->lineLen;
uchar *currentLine = buf->wp - buf->lineLen - buf->lastLF;
uchar *ptr = (uchar *)lmax((size_t)buf->buf,
(size_t)currentLine
- (buf->nLines - 1) * buf->lineLen);
@ -56,8 +55,8 @@ error_t bvgaflusher(Buffer_t *buf)
}
const size_t bufSize = buf->nLines * buf->lineLen;
ushort *fbe = BtGetBootInfo(video).framebufferAddr
+ (bufSize * sizeof(ushort));
ushort *fbe = BtVideoInfo.framebufferAddr
+ (bufSize * sizeof(ushort));
if (fbp < fbe) {
const ushort filler = VGA_ComputeEntry(' ', color);
@ -75,8 +74,8 @@ error_t IoInitVGABuffer(void)
static char bvgabuffer[1 * MB];
BStdOut = BOpenLineBuf(bvgabuffer, BS_WRONLY,
BtGetBootInfo(video).framebufferWidth,
BtGetBootInfo(video).framebufferHeight,
BtVideoInfo.framebufferWidth,
BtVideoInfo.framebufferHeight,
8, bvgaflusher);
BStdDbg = BStdOut;

3
kaleid/kernel/ke/log.c
View File

@ -22,7 +22,8 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/buf.h>
#include <extras/buf.h>
#include <kernel/base.h>
//
// Prints formatted string on standard output

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

@ -22,12 +22,13 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/log.h>
#include <kernel/buf.h>
#include <extras/buf.h>
#include <kernel/proc.h>
#include <kernel/sched.h>
#include <kernel/panic.h>
error_t vbprintf(Buffer_t *buf, const char *fmt, va_list ap);
//
// Failed assert() handler
//
@ -55,21 +56,29 @@ noreturn void KeStartPanic(const char *fmt, ...)
PsCurProc = NULL;
if (BStdOut == NULL) KeCrashSystem();
ExAttemptLock(&BStdOut->lock);
if (fmt == NULL) {
fmt = "(no message given)";
}
if (KePanicStr[0] != 0) {
KernLog("\nDouble panic!");
if (KeIsPanicking) {
vbprintf(BStdOut, "\nDouble panic!", NULL);
KeHaltCPU();
}
KeIsPanicking = 1;
// We don't check vbprintf's output
// If it fails, what could we do anyway?
vbprintf(BStdOut, "\nPanic!\n\n", NULL);
va_start(ap, fmt);
vsnprintf((char *)KePanicStr, PANICSTR_SIZE, fmt, ap);
vbprintf(BStdOut, fmt, ap);
va_end(ap);
KernLog("\nPanic!\n\n");
KernLog((char *)KePanicStr);
BStdOut->flusher(BStdOut);
KeHaltCPU();
}

1
kaleid/kernel/mm/heap.c
View File

@ -23,7 +23,6 @@
//----------------------------------------------------------------------------//
#include <kernel/mm.h>
#include <kernel/log.h>
#include <kernel/heap.h>
// Least address out of the heap

7
kaleid/kernel/mm/malloc.c
View File

@ -25,7 +25,12 @@
#include <kernel/heap.h>
#include <extras/malloc.h>
error_t KalAllocMemory(void **ptr, size_t req, int flags, size_t align)
error_t KalAllocMemory(void **ptr, size_t req)
{
return KalAllocMemoryEx(ptr, req, 0, 0);
}
error_t KalAllocMemoryEx(void **ptr, size_t req, int flags, size_t align)
{
error_t rc;
size_t brk;

16
kaleid/kernel/mm/map.c
View File

@ -23,7 +23,7 @@
//----------------------------------------------------------------------------//
#include <kernel/mm.h>
#include <kernel/log.h>
#include <kernel/boot.h>
#include <kernel/mboot.h>
// Initializes globally the memory map
@ -52,19 +52,19 @@ static error_t InitMemoryMap(void)
uint i = 0;
// sanity checks
if (!BtGetBootInfo(memory).memValid && BtGetBootInfo(memory).mapValid)
if (!BtMemoryInfo.memValid && BtMemoryInfo.mapValid)
return ENXIO;
if ((BtGetBootInfo(memory).upMemory / (MB/KB)) <= MINIMUM_RAM_SIZE)
if ((BtMemoryInfo.upMemory / (MB/KB)) <= MINIMUM_RAM_SIZE)
return ENOMEM;
// Ok then we can work ------------------------------------------------------ //
// the memory map provided by GRUB via the BIOS
currentEntry = (multiboot_memory_map_t*)BtGetBootInfo(memory).mapAddr;
currentEntry = (multiboot_memory_map_t*)BtMemoryInfo.mapAddr;
// End address of the map
mapEnd = (multiboot_memory_map_t*)
((ulong)currentEntry + (ulong)BtGetBootInfo(memory).mapLength);
((ulong)currentEntry + (ulong)BtMemoryInfo.mapLength);
// fill the map
while (currentEntry < mapEnd) {
@ -112,7 +112,7 @@ size_t MmGetAvailZoneSize(void *start) {
uint i;
// Because the kernel is the kernel
if (start < BtGetBootInfo(btldr).kernelEndAddr)
if (start < BtLoaderInfo.kernelEndAddr)
return 0;
// Search the zone where the start address is
@ -137,8 +137,8 @@ void *MmGetFirstAvailZone(void *start) {
void *current = 0;
// Because the kernel is the kernel
if ((ulong)start < (ulong)BtGetBootInfo(btldr).kernelEndAddr) {
return MmGetFirstAvailZone(BtGetBootInfo(btldr).kernelEndAddr);
if ((ulong)start < (ulong)BtLoaderInfo.kernelEndAddr) {
return MmGetFirstAvailZone(BtLoaderInfo.kernelEndAddr);
}
// Search the zone where the start address is

9
kaleid/kernel/proc/Makefile
View File

@ -1,9 +0,0 @@
sched-test:
gcc -O0 -Wall -Wextra -I../../include -c ../init/table.c -o table.o
gcc -O2 -Wall -Wextra -I../../include -c ./sched.c -o sched.o
gcc sched.o table.o -o a.out
rm sched.o table.o
clean:
rm a.out

35
kaleid/kernel/proc/sched.c → kaleid/kernel/ps/sched.c
View File

@ -25,34 +25,33 @@
#include <extras/list.h>
#include <kernel/proc.h>
#include <kernel/sched.h>
#include <kernel/log.h>
//
// For test purpose only
//
int procslen = 10;
Process_t procs[] = {
{ 0, 0, 0, 12, 12, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 1, 2, 2, 16, 16, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 2, 3, 3, 31, 31, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 3, 2, 2, 1, 1, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 4, 3, 3, 5, 5, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 5, 0, 0, 30, 30, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 6, 1, 1, 19, 19, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 7, 1, 1, 0, 0, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 8, 3, 3, 12, 12, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 9, 2, 2, 21, 21, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL, NULL, NULL },
{ 0, 0, 0, 12, 12, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 1, 2, 2, 16, 16, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 2, 3, 3, 31, 31, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 3, 2, 2, 1, 1, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 4, 3, 3, 5, 5, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 5, 0, 0, 30, 30, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 6, 1, 1, 19, 19, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 7, 1, 1, 0, 0, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 8, 3, 3, 12, 12, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
{ 9, 2, 2, 21, 21, STATE_RUNNABLE, DEF_PROC_TSLICE, DEF_PROC_TSLICE, NULL },
};
//------------------------------------------//
#define ReSchedFlag (KeCurCPU.needReSched)
#define PreemptCount (KeCurCPU.preemptCount)
#define ReSchedFlag (KeCurCPU->needReSched)
#define PreemptCount (KeCurCPU->preemptCount)
#define IdlePrioProcs (KeCurCPU.idlePrioProcs)
#define ReglPrioProcs (KeCurCPU.reglPrioProcs)
#define ServPrioProcs (KeCurCPU.servPrioProcs)
#define TimeCritProcs (KeCurCPU.timeCritProcs)
#define IdlePrioProcs (KeCurCPU->idlePrioProcs)
#define ReglPrioProcs (KeCurCPU->reglPrioProcs)
#define ServPrioProcs (KeCurCPU->servPrioProcs)
#define TimeCritProcs (KeCurCPU->timeCritProcs)
//------------------------------------------//
@ -324,7 +323,7 @@ void PsInitSched(void)
}
//
// Shutdown scheduler
// Shutdowns scheduler
//
void PsFiniSched(void)
{

382
kaleid/libbuf/bprint.c Normal file
View File

@ -0,0 +1,382 @@
//----------------------------------------------------------------------------//
// GNU GPL OS/K //
// //
// Desc: Buffer library //
// //
// //
// 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 <extras/buf.h>
#include <extras/locks.h>
error_t bputc(Buffer_t *buf, uchar ch);
error_t vbprintf(Buffer_t *buf, const char *fmt, va_list ap);
//
// Prints formatted string on buf according to fmt
//
error_t BPrintOnBuf(Buffer_t *buf, const char *fmt, ...)
{
error_t rc;
va_list ap;
va_start(ap, fmt);
ExAcquireLock(&buf->lock);
rc = vbprintf(buf, fmt, ap);
ExReleaseLock(&buf->lock);
va_end(ap);
return rc;
}
error_t BPrintOnBufV(Buffer_t *buf, const char *fmt, va_list ap)
{
error_t rc;
ExAcquireLock(&buf->lock);
rc = vbprintf(buf, fmt, ap);
ExReleaseLock(&buf->lock);
return rc;
}
//
// Prints 0 for octal, 0x for hexadecimal, 0b for binary
//
static error_t bprinthash(Buffer_t *buf, int base, int cap)
{
error_t rc;
if (base != 2 && base != 8 && base != 16) {
return EOK;
}
rc = bputc(buf, '0');
if (!rc && base != 8) {
rc = bputc(buf, (base==2 ? 'b' : (cap ? 'X' : 'x')));
}
return rc;
}
static error_t bdopadding(Buffer_t *buf, size_t width, size_t len,
char filler)
{
error_t rc = EOK;
for (; !rc && width > len ; width--) {
rc = bputc(buf, filler);
}
return rc;
}
#define CONVBUFSIZE 100
//
// Actually does BPrintOnBuf's job; doesn't lock anything
// Quite a long function
//
error_t vbprintf(Buffer_t *buf, const char *fmt, va_list ap)
{
error_t rc = 0;
int width, prec, len;
char type;
uchar uch;
char *s;
// Conversion buffer
char convbuf[CONVBUFSIZE];
// Flags
int plus, minus, space, zero, hash;
// Length modifiers
int l, h, hh;
// Signed
bool sgn;
// Capital digits
bool cap;
// Base
int base;
assert(buf && buf->initDone == INITOK);
if (!buf || !fmt) return EINVAL;
if (buf->state != BS_RDWR && buf->state != BS_WRONLY) {
return EBADF;
}
// Progress in format string
while (*fmt && !rc) {
// Deal with all non-'%' characters
if (*fmt != '%') {
rc = bputc(buf, *fmt);
fmt++;
continue;
}
//
// %[parameter][flags][width|*][.precision|*][length]type
// We aren't dealing with parameters and floating stuff just yet
//
// Skip the '%'
fmt++;
// "%%" modifier
if (*fmt == '%') {
rc = bputc(buf, '%');
fmt++;
continue;
}
// Reset everything
cap = sgn = 0;
l = h = hh = 0;
width = prec = 0;
plus = minus = space = zero = hash = 0;
//
// Flags field
//
while (*fmt) {
if (*fmt == '#') { fmt++; hash++; }
else if (*fmt == '0') { fmt++; zero++; }
else if (*fmt == '+') { fmt++; plus++; }
else if (*fmt == '-') { fmt++; minus++; }
else if (*fmt == ' ') { fmt++; space++; }
// Next field
else break;
}
//
// Width & precision fields
// A width field of zero is ignored
//
// Extracts either width or precision
#define bextractwp(name) \
do { \
if (*fmt == '*') { \
fmt++; \
name = va_arg(ap, int); \
} else { \
while (isdigit(*fmt) && name < CONVBUFSIZE) { \
name = 10 * name + (*fmt - '0'); \
fmt++; \
} \
} \
} while (0)
// Extract width
bextractwp(width);
// A width below 0 activates the "minus" flag
if (width < 0) {
width = -width;
minus++;
}
// Extract precision
if (*fmt == '.') {
fmt++;
bextractwp(prec);
}
// Make sure they're not too big
if (width > CONVBUFSIZE || prec > CONVBUFSIZE) {
rc = EINVAL;
break;
}
//
// Length field
//
while (*fmt) {
if (*fmt == 'l' || *fmt == 'z' || *fmt == 't') {
fmt++;
l++;
}
else if (*fmt == 'h') {
fmt++;
h++;
}
// Next field
else break;
}
// Consistency check
assert(!(l > 0 && h > 0));
assert(!(l > 2 || h > 1));
//
// The type field
//
type = *fmt++;
// Characters
if (type == 'c') {
uch = (uchar)va_arg(ap, int);
bputc(buf, uch);
continue;
}
// Strings
else if (type == 's') {
s = va_arg(ap, char *);
if (s == NULL) s = "(null)";
// For strings, the precision field gives the maximum
// amount of characters to be read from the stream
// Zero/nonspecified precision means unlimited amount
if (prec == 0) prec = INT_MAX;
for (; *s && prec-- ; s++) {
rc = bputc(buf, (uchar)*s);
}
continue;
}
// Decimal, unsigned decimal, hexadecimal, octal and binary numbers
else if (type == 'd' || type == 'i') { base = 10; sgn = 1; }
else if (type == 'X') { base = 16; cap = 1; }
else if (type == 'x') { base = 16; }
else if (type == 'u') { base = 10; }
else if (type == 'o') { base = 8; }
else if (type == 'b') { base = 2; }
// Pointers: %p = %#012lx
// (48-bit pointers have width 12 at least)
else if (type == 'p') {
type = 'x'; base = 16; zero++; hash++; l++;
if (width < 12) width = 12;
}
// Unknown/unsupported modifier
// Note: a '\0' after length field falls here
else {
rc = EINVAL;
break;
}
//
// Numerical conversions
//
// We use s to iterate convbuf
s = convbuf;
// FIXME: this works, but is ugly as hell
#define bdoconvrt(pref, type, vtype) \
do { \
type i_##type = (type)va_arg(ap, vtype); \
pref##toa(i_##type, s, base); \
} while (0)
if (!l) {
if (sgn) {
if (h == 0) bdoconvrt(i, int, int);
if (h == 1) bdoconvrt(i, short, int);
} else {
if (h == 0) bdoconvrt(u, uint, uint);
if (h == 1) bdoconvrt(u, ushort, uint);
}
}
else {
if (sgn) bdoconvrt(l, long, long);
else bdoconvrt(ul, ulong, ulong);
}
//
// Implement flags and %X, and prints
//
// Capital letter digits
if (base > 10 && cap) {
for (; *s ; s++)
if (islower(*s)) *s = toupper(*s);
// We use this "opportunity" to compute the length of s
len = s - convbuf;
// Reset s
s = convbuf;
}
// Compute s's length
// It will always fit in an int
else len = (int)strlen(s);
// Adjust width
if (sgn && (plus || space)) width--;
else if (hash) width -= (base==8 ? 1 : ((base==2||base==16) ? 2 : 0));
// When padding with spaces, we pad before +/-'s etc
if (!minus && !zero && width > len)
bdopadding(buf, width, len, ' ');
// Deal with signs and the hash flag
if (*s == '-') { rc = bputc(buf, '-'); s++, len--; }
else if (sgn && plus) rc = bputc(buf, '+');
else if (sgn && space) rc = bputc(buf, ' ');
else if (hash) bprinthash(buf, base, cap);
// Deal with padding by zeroes
// The 'minus' flag makes no sense with the 'zero' one
if (zero && width > len)
bdopadding(buf, width, len, '0');
//
// Output the actual number
//
for (; !rc && *s ; s++) {
rc = bputc(buf, (uchar)*s);
}
// 'minus' padding, only with spaces
if (minus && !zero && width > len)
bdopadding(buf, width, base, ' ');
// Carry on to next modifier
}
// Assert rc for debugging purposes
assert(!rc);
return rc;
}

3
kaleid/kernel/buf/bput.c → kaleid/libbuf/bput.c
View File

@ -22,7 +22,8 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/buf.h>
#include <extras/buf.h>
#include <extras/locks.h>
error_t bputc(Buffer_t *buf, uchar ch);

7
kaleid/kernel/buf/buf.c → kaleid/libbuf/buf.c
View File

@ -22,7 +22,8 @@
// along with OS/K. If not, see <https://www.gnu.org/licenses/>. //
//----------------------------------------------------------------------------//
#include <kernel/buf.h>
#include <extras/buf.h>
#include <extras/locks.h>
#include <extras/malloc.h>
Buffer_t *BStdOut, *BStdDbg;
@ -57,7 +58,7 @@ error_t BCloseBuf(Buffer_t *buf)
}
if (buf->flags & BF_ALLOC) {
free(buf->buf);
KalFreeMemory(buf->buf);
}
buf->buf = buf->rp = buf->wp = NULL;
@ -110,7 +111,7 @@ Buffer_t *BOpenLineBuf(char *source, int mode,
buf->size = lineLen * nLines * (pbCount + 1);
if (source == NULL) {
buf->buf = calloc(buf->size, 1);
KalAllocMemoryEx((void **)&buf->buf, buf->size, M_ZEROED, 0);
} else {
buf->buf = (uchar *)source;
}

0
kaleid/crtlib/atoi.c → kaleid/libc/atoi.c
View File

0
kaleid/crtlib/ctype.c → kaleid/libc/ctype.c
View File

0
kaleid/crtlib/itoa.c → kaleid/libc/itoa.c
View File

12
kaleid/crtlib/mem.c → kaleid/libc/mem.c
View File

@ -36,7 +36,7 @@ void *malloc(size_t n)
void *ptr;
error_t rc;
rc = KalAllocMemory(&ptr, n, 0, 0);
rc = KalAllocMemory(&ptr, n);
if (rc > 0) seterrno(rc);
return ptr;
@ -44,9 +44,13 @@ void *malloc(size_t n)
void *calloc(size_t n, size_t m)
{
char *mem = malloc(n * m);
memzero(mem, n * m);
return mem;
void *ptr;
error_t rc;
rc = KalAllocMemoryEx(&ptr, n * m, M_ZEROED, 0);
if (rc > 0) seterrno(rc);
return ptr;
}
void free(void *ptr)

0
kaleid/crtlib/rand.c → kaleid/libc/rand.c
View File

6
kaleid/crtlib/sprintf.c → kaleid/libc/sprintf.c
View File

@ -31,12 +31,6 @@
//
// Format str according to fmt using ellipsed arguments
//
// Standard is dumb so we won't follow it:
// 1) we return a size_t instead of int
// 2) for (v)snprintf we return the number of characters written
// instead of the number of characters that would have been written
// given large enough n
//
size_t sprintf(char *str, const char *fmt, ...)
{
int ret;

0
kaleid/crtlib/status.c → kaleid/libc/status.c
View File

0
kaleid/crtlib/string.c → kaleid/libc/string.c
View File

0
kaleid/crtlib/strtol.c → kaleid/libc/strtol.c
View File