merge master ok

2019-04-11 08:35:00 +02:00 · 2019-04-11 08:35:00 +02:00 · 831591d996
parent 082a1b82d8 31918c2e6f
commit 831591d996
60 changed files with 973 additions and 962 deletions
--- a/.stylehlp
+++ b/.stylehlp
@ -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/>.             #
+#=----------------------------------------------------------------------------=#
--- a/.stylehlp_asm
+++ b/.stylehlp_asm
@ -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/>.             ;
-;=----------------------------------------------------------------------------=;
--- a/.stylehlp_c
+++ b/.stylehlp_c
@ -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/>.            //
-//----------------------------------------------------------------------------//
--- a/6
+++ b/6
@ -40,4 +40,8 @@
            - We have implemented a buffer library for our terminal
            - The stack is now 8MB long and isn't anymore in conflict with the kernel space xD
            - The terminal is now better (with sprintf functions)
-
+2019/04/09 More improvements
+            - The terminal is now buffered (static) and we have made a big reorganization of the project
+            - The Makefile suffered a lot, so we improved it
+            - panic doesn't need to lock the terminal
+            - We have a (basic) heap and memory allocator
--- a/247
+++ b/247
@ -22,166 +22,84 @@
 #   along with OS/K.  If not, see <https://www.gnu.org/licenses/>.             #
 #=----------------------------------------------------------------------------=#

+.PHONY: all test test32 debug gdb install_mbr dust clean OS/K
+
 ## VARIABLES ----------------------------------------------------------------- #

-#Programs
-ASM=nasm
-LD=ld
-CCNAME=x86_64-elf-gcc
+# Debug
+mode ?= debug

+# Programs
+ASM=nasm
+LD=x86_64-elf-ld
+OBJCOPY=x86_64-elf-objcopy
+CCNAME=x86_64-elf-gcc
 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
+CFLAGS2= -c -mno-red-zone -mno-mmx -mno-sse -mno-sse2
 CFLAGS=$(CFLAGS1) $(CFLAGS2)
+
+ifeq ($(mode), release)
+CFLAGS += -D_NO_DEBUG
+dep += dust
+endif
+ifeq ($(mode), debug)
+CFLAGS += -g
+endif
+
 KCC=$(CCNAME) $(COPTIM) $(CWARNS) $(CFLAGS) $(CINCLUDES) -D_OSK_SOURCE -D_KALEID_KERNEL

-#Folders
+# Folders
 MBRDIR=boot/grub
 LOADERDIR=boot/loader
-KERNELDIR=kaleid
+KALEIDDIR=kaleid
+INCLUDEDIR=include
 OBJDIR=build/obj
 KOBJDIR=build/obj/kaleid
 LOBJDIR=build/obj/boot
 BINDIR=build/bin
 BUILDDIR=build
+vpath %.c $(KALEIDDIR)

-#Color codes
+# Color codes
 CL='\033[0;32m'
 CL2='\033[1;36m'
 CL3='\033[0m'
 NC='\033[1;37m'


-.PHONY: all
-all : OS/K
+## SOURCES INSCRIPTION-------------------------------------------------------- #
+
+# Lib C sources
+LibCSources=	libc/atoi.c libc/itoa.c                                        \
+		libc/mem.c libc/ctype.c                                        \
+		libc/rand.c libc/sprintf.c                                     \
+		libc/status.c libc/string.c                                    \
+		libc/strtol.c extras/argv.c                                    \
+		extras/prog.c
+
+KernObj=$(patsubst %.c,$(KOBJDIR)/%.o,$(KernSources))
+
+# Kernel sources
+KernSources=	libbuf/buf.c libbuf/bput.c                                     \
+		libbuf/bprint.c kernel/cpu/cpuid.c                             \
+		kernel/cpu/idt.c kernel/init/init.c                            \
+		kernel/init/table.c kernel/io/cursor.c                         \
+		kernel/ke/log.c kernel/io/vga.c                                \
+		kernel/ke/panic.c kernel/mm/map.c                              \
+		kernel/mm/heap.c kernel/mm/malloc.c                            \
+		kernel/mm/gdt.c kernel/ps/sched.c                              \
+
+LibCObj=$(patsubst %.c,$(KOBJDIR)/%.o,$(LibCSources))
+

 ## KALEID MAKEFILE ----------------------------------------------------------- #

-# Common objects
-kal_com_obj= $(KOBJDIR)/atoi.o $(KOBJDIR)/ctype.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                                 \
-	 $(KOBJDIR)/prog.o $(KOBJDIR)/atol.o                                   \
-	 $(KOBJDIR)/atou.o $(KOBJDIR)/atoul.o                                  \
-	 $(KOBJDIR)/utoa.o $(KOBJDIR)/ltoa.o                                   \
-	 $(KOBJDIR)/ultoa.o
-
-$(KOBJDIR)/atoi.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ATOI $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/atol.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ATOL $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/atou.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ATOU $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/atoul.o: $(KERNELDIR)/crtlib/atoi.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ATOUL $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/ctype.o: $(KERNELDIR)/crtlib/ctype.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/itoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ITOA $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/ltoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_LTOA $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/utoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_UTOA $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/ultoa.o: $(KERNELDIR)/crtlib/itoa.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -D_NEED_ULTOA $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/mem.o: $(KERNELDIR)/crtlib/mem.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) -fno-strict-aliasing $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/rand.o: $(KERNELDIR)/crtlib/rand.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/sprintf.o: $(KERNELDIR)/crtlib/sprintf.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/status.o: $(KERNELDIR)/crtlib/status.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/string.o: $(KERNELDIR)/crtlib/string.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/strtol.o: $(KERNELDIR)/crtlib/strtol.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/argv.o: $(KERNELDIR)/extras/argv.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/prog.o: $(KERNELDIR)/extras/prog.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-
-# Kernel objects
-kal_kern_obj= $(KOBJDIR)/kernel/cpuid.o $(KOBJDIR)/kernel/init.o           \
-	  $(KOBJDIR)/kernel/table.o $(KOBJDIR)/kernel/cursor.o                 \
-	  $(KOBJDIR)/kernel/log.o   $(KOBJDIR)/kernel/vga.o                    \
-	  $(KOBJDIR)/kernel/panic.o $(KOBJDIR)/kernel/map.o                    \
-	  $(KOBJDIR)/kernel/heap.o  $(KOBJDIR)/kernel/malloc.o                 \
-	  $(KOBJDIR)/kernel/buf.o   $(KOBJDIR)/kernel/sched.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
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/idt.o: $(KERNELDIR)/kernel/cpu/idt.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/init.o: $(KERNELDIR)/kernel/init/init.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/table.o: $(KERNELDIR)/kernel/init/table.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/cursor.o: $(KERNELDIR)/kernel/io/cursor.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/log.o: $(KERNELDIR)/kernel/ke/log.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/vga.o: $(KERNELDIR)/kernel/io/vga.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/panic.o: $(KERNELDIR)/kernel/ke/panic.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/map.o: $(KERNELDIR)/kernel/mm/map.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/heap.o: $(KERNELDIR)/kernel/mm/heap.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-$(KOBJDIR)/kernel/malloc.o: $(KERNELDIR)/kernel/mm/malloc.c $(KERNELDIR)/include/*/*.h
-	@$(KCC) $< -o $@
-$(KOBJDIR)/kernel/gdt.o: $(KERNELDIR)/kernel/mm/gdt.c $(KERNELDIR)/include/*/*.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
-	@$(KCC) $< -o $@
-	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
-
+all : OS/K $(dep)

 ## MISC MAKEFILE ------------------------------------------------------------- #
 ./ProjectTree: ./.stylehlp_sh
@ -189,24 +107,56 @@ $(KOBJDIR)/kernel/sched.o: $(KERNELDIR)/kernel/proc/sched.c $(KERNELDIR)/include
 	@echo "\n" >> ./ProjectTree
 	@tree --dirsfirst >> ./ProjectTree
 	@echo ${CL2}[$@] ${CL}Generated.${CL3}
+
+$(KOBJDIR):
+	@mkdir -p $(KOBJDIR)
+
+## LIB C MAKEFILE ------------------------------------------------------------ #
+$(KOBJDIR)/libc/atoi.o: $(KALEIDDIR)/libc/atoi.c $(INCLUDEDIR)/*/*.h | $(KOBJDIR)
+	@mkdir -p $(shell dirname $@)
+	@$(KCC) -D_NEED_ATOI $< -o $@.1
+	@$(KCC) -D_NEED_ATOL $< -o $@.2
+	@$(KCC) -D_NEED_ATOU $< -o $@.3
+	@$(KCC) -D_NEED_ATOUL $< -o $@.4
+	@$(LD) -r $@.1 $@.2 $@.3 $@.4 -o $@
+	@rm -f $@.1 $@.2 $@.3 $@.4
+	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
+
+$(KOBJDIR)/libc/itoa.o: $(KALEIDDIR)/libc/itoa.c $(INCLUDEDIR)/*/*.h | $(KOBJDIR)
+	@mkdir -p $(shell dirname $@)
+	@$(KCC) -D_NEED_ITOA $< -o $@.1
+	@$(KCC) -D_NEED_LTOA $< -o $@.2
+	@$(KCC) -D_NEED_UTOA $< -o $@.3
+	@$(KCC) -D_NEED_ULTOA $< -o $@.4
+	@$(LD) -r $@.1 $@.2 $@.3 $@.4 -o $@
+	@rm -f $@.1 $@.2 $@.3 $@.4
+	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
+
+$(KOBJDIR)/libc/mem.o: $(KALEIDDIR)/libc/mem.c $(INCLUDEDIR)/*/*.h | $(KOBJDIR)
+	@mkdir -p $(shell dirname $@)
+	@$(KCC) -fno-strict-aliasing $< -o $@
+	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
+
 ## MAIN MAKEFILE ------------------------------------------------------------- #

-.PHONY: test
+$(KOBJDIR)/%.o: %.c $(INCLUDEDIR)/*/*.h | $(KOBJDIR)
+	@mkdir -p $(shell dirname $@)
+	@$(KCC) $< -o $@
+	@echo ${CL2}[$@] ${CL}Compiled.${CL3}
+
 test: all
 	@qemu-system-x86_64 -m 4G -hda $(BUILDDIR)/bin/disk.img \
 	-d cpu_reset,guest_errors,pcall,int 2> $(BUILDDIR)/qemu.log &
-.PHONY: test32
+
 test32: all
 	@qemu-system-i386 -hda $(BUILDDIR)/bin/disk.img -d cpu_reset,guest_errors,pcall,int 2> $(BUILDDIR)/qemu.log &

-.PHONY: debug
 debug: all
 	@qemu-system-x86_64 -m 64M -hda $(BUILDDIR)/bin/disk.img -no-reboot \
 	-no-shutdown -d cpu_reset,guest_errors,pcall,int 2> $(BUILDDIR)/qemu.log &
 	@ndisasm $(BINDIR)/kaleid -o 0x00100000 -b 64 > $(BUILDDIR)/kaleid64_disasm.asm
 	@ndisasm $(BINDIR)/kaleid -o 0x00100000 -b 32 > $(BUILDDIR)/kaleid32_disasm.asm

-.PHONY: gdb
 gdb: all
 	@qemu-system-x86_64 -m 64M -hda $(BUILDDIR)/bin/disk.img -no-reboot \
 	-no-shutdown -d cpu_reset,guest_errors,pcall,int -s 2> $(BUILDDIR)/qemu.log &
@ -218,7 +168,6 @@ gdb: all
 	-ex "symbol-file $(BINDIR)/kaleid" \
 	-ex "break BtStartKern"            \

-.PHONY: install_mbr
 install_mbr: $(BINDIR)/disk.img $(MBRDIR)/grub.cfg
 	@mkdir -p $(BINDIR)/disk
 	@echo ${CL2}[$@] ${NC}Installing MBR on image...${CL3}
@ -227,30 +176,31 @@ install_mbr: $(BINDIR)/disk.img $(MBRDIR)/grub.cfg
 	@rmdir $(BINDIR)/disk
 	@echo ${CL2}[$@] ${CL}Success.${CL3}

-.PHONY: clean
+dust:
+	-@$(MBRDIR)/umount.sh $(BINDIR)/disk || /bin/true
+	@rm -Rf $(OBJDIR)/*
+	@echo ${CL2}[$@] ${CL}Cleaned.${CL3}
 clean:
 	-@$(MBRDIR)/umount.sh $(BINDIR)/disk || /bin/true
-	@rm -Rvf ./ProjectTree
-	@rm -Rvf $(BINDIR)/* $(OBJDIR)/*.o \
-		$(OBJDIR)/*/*.o $(OBJDIR)/*/*.x86_64 $(OBJDIR)/*/*/*.o
-	@echo ${CL2}[[$@]] ${CL}Cleaned.${CL3}
+	@rm -Rvf ./ProjectTree $(BUILDDIR)/*.log
+	@rm -Rvf $(BINDIR)/* $(OBJDIR)/*
+	@echo ${CL2}[$@] ${CL}Cleaned.${CL3}

 $(BINDIR)/kaleid: $(LOBJDIR)/kaleid.x86_64
 	@echo ${CL2}[$@] ${NC}Objcopy...${CL3}
-	@x86_64-elf-objcopy -I elf64-x86-64 -O elf32-i386 $(LOBJDIR)/kaleid.x86_64 $(BINDIR)/kaleid
+	@$(OBJCOPY) -I elf64-x86-64 -O elf32-i386 $(LOBJDIR)/kaleid.x86_64 $(BINDIR)/kaleid
 	@echo ${CL2}[$@] ${CL}Success.${CL3}

-$(LOBJDIR)/kaleid.x86_64: $(kal_kern_obj) $(kal_com_obj) $(LOBJDIR)/loader.o
+$(LOBJDIR)/kaleid.x86_64: $(LibCObj) $(KernObj) $(LOBJDIR)/loader.o
 	@echo ${CL2}[$@] ${NC}Linking kernel objects...${CL3}
 	@$(LD) $(LDFLAGS) -T $(BUILDDIR)/kernel.ld			\
-		$(LOBJDIR)/loader.o		\
-		$(KOBJDIR)/*.o 		\
-		$(KOBJDIR)/kernel/*.o	\
+		$(LOBJDIR)/loader.o $(KernObj) $(LibCObj)		\
 		-o $(LOBJDIR)/kaleid.x86_64
 	@echo ${CL2}[$@] ${CL}Success.${CL3}

 $(LOBJDIR)/loader.o: $(LOADERDIR)/loader.asm $(LOADERDIR)/*/*.inc
 	@echo ${CL2}[$@] ${NC}Making loader...${CL3}
+	@mkdir -p $(shell dirname $@)
 	@$(ASM) $(ASMFLAGS) $(LOADERDIR)/loader.asm -o $(LOBJDIR)/loader.o > /dev/null
 	@echo ${CL2}[$@] ${CL}Success.${CL3}

@ -261,10 +211,9 @@ $(BINDIR)/disk.img: $(MBRDIR)/create_disk.sh
 	@make install_mbr
 	@echo ${CL2}[$@]${NC} Constructing disk image...${CL3}

-.PHONY:OS/K
 OS/K: $(BINDIR)/kaleid $(BINDIR)/disk.img ./ProjectTree
 	@mkdir -p $(BINDIR)/disk
-	@echo ${CL2}[[$@]] ${NC}Integrating kernel...${CL3}
+	@echo ${CL2}[[$@]] ${NC}Integrating kernel, $(mode) mode.${CL3}
 	-@$(MBRDIR)/umount.sh $(BINDIR)/disk || /bin/true
 	@$(MBRDIR)/mount.sh $(BINDIR)/disk.img $(BINDIR)/disk
 	@cp $(BINDIR)/kaleid $(BINDIR)/disk/boot/kaleid
--- a/185
+++ b/185
@ -55,116 +55,127 @@
 │   │   │   ├── kaleid.x86_64
 │   │   │   └── loader.o
 │   │   └── kaleid
+│   │       ├── extras
+│   │       │   ├── argv.o
+│   │       │   └── prog.o
 │   │       ├── kernel
+│   │       │   ├── cpu
+│   │       │   │   ├── cpuid.o
+│   │       │   │   └── idt.o
+│   │       │   ├── init
+│   │       │   │   ├── init.o
+│   │       │   │   └── table.o
+│   │       │   ├── io
+│   │       │   │   ├── cursor.o
+│   │       │   │   └── vga.o
+│   │       │   ├── ke
+│   │       │   │   ├── log.o
+│   │       │   │   └── panic.o
+│   │       │   ├── mm
+│   │       │   │   ├── gdt.o
+│   │       │   │   ├── heap.o
+│   │       │   │   ├── malloc.o
+│   │       │   │   └── map.o
+│   │       │   └── ps
+│   │       │       └── sched.o
+│   │       ├── libbuf
 │   │       │   ├── bprint.o
 │   │       │   ├── bput.o
-│   │       │   ├── buf.o
-│   │       │   ├── cpuid.o
-│   │       │   ├── cursor.o
-│   │       │   ├── gdt.o
-│   │       │   ├── heap.o
-│   │       │   ├── init.o
-│   │       │   ├── log.o
-│   │       │   ├── malloc.o
-│   │       │   ├── map.o
-│   │       │   ├── panic.o
-│   │       │   ├── sched.o
-│   │       │   ├── table.o
-│   │       │   └── vga.o
-│   │       ├── argv.o
+│   │       │   └── buf.o
+│   │       └── libc
 │   │           ├── atoi.o
-│   │       ├── atol.o
-│   │       ├── atoul.o
-│   │       ├── atou.o
+│   │           ├── atoi.o.1
+│   │           ├── atoi.o.2
+│   │           ├── atoi.o.3
+│   │           ├── atoi.o.4
 │   │           ├── ctype.o
 │   │           ├── itoa.o
-│   │       ├── ltoa.o
+│   │           ├── itoa.o.1
+│   │           ├── itoa.o.2
+│   │           ├── itoa.o.3
+│   │           ├── itoa.o.4
 │   │           ├── mem.o
-│   │       ├── prog.o
 │   │           ├── rand.o
 │   │           ├── sprintf.o
 │   │           ├── status.o
 │   │           ├── string.o
-│   │       ├── strtol.o
-│   │       ├── ultoa.o
-│   │       └── utoa.o
+│   │           └── strtol.o
 │   ├── grub.log
 │   └── kernel.ld
+├── 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
+│   ├── 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
-│       ├── 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
+│   └── 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
+37 directories, 116 files
--- a/README.md
+++ b/README.md
@ -11,6 +11,8 @@ For changelog, see [ChangeLog](ChangeLog)

 For structure of the sources, see [ProjectTree](ProjectTree)

+For our IRC channel, see `#os.k-devel` on [Freenode](https://webchat.freenode.net)
+
 Note that every file within OS/K is written using spaces for tabulation, with each
 tabulation being 4 spaces long.

@ -20,10 +22,10 @@ To compile this project from sources, you must first install the dependencies

 ```
 apt update && apt upgrade
-apt install grub-pc dosfstools make nasm qemu
+apt install grub-pc-bin dosfstools make nasm qemu tree
 ```

-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`` directory 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
 ```
+
--- a/boot/grub/grub.cfg
+++ b/boot/grub/grub.cfg
@ -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

--- a/build/obj/boot/.placeholder
+++ b/build/obj/boot/.placeholder
--- a/build/obj/kaleid/kernel/.placeholder
+++ b/build/obj/kaleid/kernel/.placeholder
--- a/kaleid/include/base/assert.h
+++ b/kaleid/include/base/assert.h
--- a/kaleid/include/base/bdefs.h
+++ b/kaleid/include/base/bdefs.h
--- a/kaleid/include/base/crtlib.h
+++ b/kaleid/include/base/crtlib.h
--- a/kaleid/include/base/errno.h
+++ b/kaleid/include/base/errno.h
--- a/kaleid/include/base/limits.h
+++ b/kaleid/include/base/limits.h
--- a/kaleid/include/base/masks.h
+++ b/kaleid/include/base/masks.h
--- a/kaleid/include/base/types.h
+++ b/kaleid/include/base/types.h
--- a/kaleid/include/extras/argv.h
+++ b/kaleid/include/extras/argv.h
--- a/kaleid/include/kernel/buf.h
+++ b/kaleid/include/kernel/buf.h
@ -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
--- a/kaleid/include/extras/list.h
+++ b/kaleid/include/extras/list.h
--- a/kaleid/include/extras/locks.h
+++ b/kaleid/include/extras/locks.h
--- a/kaleid/include/extras/malloc.h
+++ b/kaleid/include/extras/malloc.h
@ -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);

 //------------------------------------------//
--- a/kaleid/include/extras/prog.h
+++ b/kaleid/include/extras/prog.h
--- a/kaleid/include/kalbase.h
+++ b/kaleid/include/kalbase.h
--- a/kaleid/include/kaleid.h
+++ b/kaleid/include/kaleid.h
--- a/kaleid/include/kalext.h
+++ b/kaleid/include/kalext.h
--- a/include/kernel/base.h
+++ b/include/kernel/base.h
@ -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
+
--- a/kaleid/include/kernel/base.h
+++ b/kaleid/include/kernel/base.h
@ -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
-
--- a/kaleid/include/kernel/cpu.h
+++ b/kaleid/include/kernel/cpu.h
--- a/kaleid/include/kernel/heap.h
+++ b/kaleid/include/kernel/heap.h
--- a/kaleid/include/kernel/iomisc.h
+++ b/kaleid/include/kernel/iomisc.h
--- a/kaleid/include/kernel/mboot.h
+++ b/kaleid/include/kernel/mboot.h
--- a/kaleid/include/kernel/mm.h
+++ b/kaleid/include/kernel/mm.h
@ -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__));

 // -------------------------------------------------------------------------- //

--- a/kaleid/include/kernel/panic.h
+++ b/kaleid/include/kernel/panic.h
@ -32,7 +32,7 @@
 //------------------------------------------//

 #define PANICSTR_SIZE 1024
-extern volatile char KePanicStr[PANICSTR_SIZE];
+extern volatile bool KeIsPanicking;

 //------------------------------------------//

--- a/kaleid/include/kernel/proc.h
+++ b/kaleid/include/kernel/proc.h
@ -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 *);
--- a/kaleid/include/kernel/sched.h
+++ b/kaleid/include/kernel/sched.h
@ -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)

 //------------------------------------------//

--- a/kaleid/include/kernel/log.h
+++ b/kaleid/include/kernel/log.h
@ -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
--- a/kaleid/kernel/buf/bprint.c
+++ b/kaleid/kernel/buf/bprint.c
@ -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;
-}
-
--- a/kaleid/kernel/init/init.c
+++ b/kaleid/kernel/init/init.c
@ -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,13 +139,13 @@ 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();

    // Several inits
@ -159,7 +157,8 @@ noreturn void BtStartKern(multiboot_info_t *mbInfo, uint mbMagic)

    MmPrintMemoryMap();

-    // We're out
-    PsFiniSched();
-    KeCrashSystem(); //yay
+    //KeStartPanic("Test Panic %d", 4);
+
+    // End this machine's suffering
+    KeCrashSystem();
 }
--- a/kaleid/kernel/init/table.c
+++ b/kaleid/kernel/init/table.c
@ -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];
--- a/kaleid/kernel/io/vga.c
+++ b/kaleid/kernel/io/vga.c
@ -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,7 +55,7 @@ error_t bvgaflusher(Buffer_t *buf)
    }

    const size_t bufSize = buf->nLines * buf->lineLen;
-    ushort *fbe = BtGetBootInfo(video).framebufferAddr
+    ushort *fbe = BtVideoInfo.framebufferAddr
                                     + (bufSize * sizeof(ushort));

    if (fbp < fbe) {
@ -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;
--- a/kaleid/kernel/ke/log.c
+++ b/kaleid/kernel/ke/log.c
@ -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
--- a/kaleid/kernel/ke/panic.c
+++ b/kaleid/kernel/ke/panic.c
@ -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();
 }
--- a/kaleid/kernel/mm/heap.c
+++ b/kaleid/kernel/mm/heap.c
@ -23,7 +23,6 @@
 //----------------------------------------------------------------------------//

 #include <kernel/mm.h>
-#include <kernel/log.h>
 #include <kernel/heap.h>

 // Least address out of the heap
--- a/kaleid/kernel/mm/malloc.c
+++ b/kaleid/kernel/mm/malloc.c
@ -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;
--- a/kaleid/kernel/mm/map.c
+++ b/kaleid/kernel/mm/map.c
@ -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) {
@ -113,7 +113,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
@ -138,8 +138,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
--- a/kaleid/kernel/proc/Makefile
+++ b/kaleid/kernel/proc/Makefile
@ -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
--- a/kaleid/kernel/proc/sched.c
+++ b/kaleid/kernel/proc/sched.c
@ -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)
 {
--- a/kaleid/libbuf/bprint.c
+++ b/kaleid/libbuf/bprint.c
@ -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;
+}
+
--- a/kaleid/kernel/buf/bput.c
+++ b/kaleid/kernel/buf/bput.c
@ -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);

--- a/kaleid/kernel/buf/buf.c
+++ b/kaleid/kernel/buf/buf.c
@ -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;
    }
--- a/kaleid/crtlib/atoi.c
+++ b/kaleid/crtlib/atoi.c
--- a/kaleid/crtlib/ctype.c
+++ b/kaleid/crtlib/ctype.c
--- a/kaleid/crtlib/itoa.c
+++ b/kaleid/crtlib/itoa.c
--- a/kaleid/crtlib/mem.c
+++ b/kaleid/crtlib/mem.c
@ -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)
--- a/kaleid/crtlib/rand.c
+++ b/kaleid/crtlib/rand.c
--- a/kaleid/crtlib/sprintf.c
+++ b/kaleid/crtlib/sprintf.c
@ -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;
--- a/kaleid/crtlib/status.c
+++ b/kaleid/crtlib/status.c
--- a/kaleid/crtlib/string.c
+++ b/kaleid/crtlib/string.c
--- a/kaleid/crtlib/strtol.c
+++ b/kaleid/crtlib/strtol.c