diff --git a/.gitignore b/.gitignore index 7840e6a..42f9498 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,10 @@ test-*.c *.elf *.S +# CNAME STUFF +*.yml +CNAME + # Linker output *.ilk diff --git a/AUTHORS b/AUTHORS new file mode 100644 index 0000000..3c74434 --- /dev/null +++ b/AUTHORS @@ -0,0 +1,41 @@ +#=----------------------------------------------------------------------------=# +# GNU GPL OS/K # +# # +# Desc: Project Authors 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 . # +#=----------------------------------------------------------------------------=# + +The OS/K development team (named in the sources The OS/K Team) is composed of +all contributors of the project. Its representatives are the owners of the OS/K +project repository, and own the copyright in it. + + Founders and owner of the OS/K project repository + + Julian Barathieu (julianb0) + Adrien Bourmault (NeoX95) + + Main contributors + + Julian Barathieu (julianb0) + Adrien Bourmault (NeoX95) + + Other contributors + + (void) diff --git a/CNAME b/CNAME new file mode 100644 index 0000000..2821c3b --- /dev/null +++ b/CNAME @@ -0,0 +1 @@ +www.os-k.eu \ No newline at end of file diff --git a/ChangeLog b/ChangeLog index b019064..9410f1e 100644 --- a/ChangeLog +++ b/ChangeLog @@ -1,13 +1,26 @@ -//----------------------------------------------------------------------------// -// GNU GPL OS/K // -// // -// Authors: spectral` // -// NeoX // -// // -// Desc: ChangeLog #1 // -// From: 2018/12/06 // -// UpTo: current // -//----------------------------------------------------------------------------// +#=----------------------------------------------------------------------------=# +# GNU GPL OS/K # +# # +# Desc: Project ChangeLog # +# # +# # +# 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 . # +#=----------------------------------------------------------------------------=# 2018/10/?? - Started talking about making our own OS 2018/11/?? - Name decided & creation of os-k.eu diff --git a/Makefile b/Makefile index 6458c3c..79e3b32 100644 --- a/Makefile +++ b/Makefile @@ -1,11 +1,26 @@ -#----------------------------------------------------------------------------# -# GNU GPL OS/K # -# # -# Authors: spectral` # -# NeoX # -# # -# Desc: Project Makefile # -#----------------------------------------------------------------------------# +#=----------------------------------------------------------------------------=# +# GNU GPL OS/K # +# # +# Desc: Project Makefile # +# # +# # +# 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 . # +#=----------------------------------------------------------------------------=# kernel: cpp ./Makefile.in > build/Makefile.out diff --git a/Makefile.in b/Makefile.in index 3b7a9c6..e965c0b 100644 --- a/Makefile.in +++ b/Makefile.in @@ -1,11 +1,28 @@ -//----------------------------------------------------------------------------// +// -*- Mode: Makefile -*- + +//=--------------------------------------------------------------------------=// // GNU GPL OS/K // // // -// Authors: spectral` // -// NeoX // -// // // Desc: Project Makefile // -//----------------------------------------------------------------------------// +// // +// // +// 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 . // +//=--------------------------------------------------------------------------=// // The madman's Makefile #include "build/preproc.h" @@ -13,23 +30,23 @@ CCNAME="/opt/cross-cc/bin/x86_64-elf-gcc" CC2NAME=gcc COPTIM=-O2 -CWARNS=-Wall -Wextra -Wshadow -Wpedantic -CINCLUDES=-isystem./kaleid/include +CWARNS=-Wall -Wextra // -Wshadow -Wpedantic +CINCLUDES=-Ikaleid/include -CFLAGS1=-std=gnu11 -nostdlib -ffreestanding -mcmodel=large -CFLAGS2=-m64 -masm=intel -mno-red-zone -mno-mmx -mno-sse -mno-sse2 -CFLAGS=$(CFLAGS1) $(CFLAGS2) $(SFLAG) +CFLAGS1=-nostdlib -ffreestanding -mcmodel=large // -std=gnu11 +CFLAGS2=_ASMTYPE -mno-red-zone -mno-mmx -mno-sse -mno-sse2 +CFLAGS=$(CFLAGS1) $(CFLAGS2) CC=$(CCNAME) $(COPTIM) $(CWARNS) $(CFLAGS) $(CINCLUDES) -BINDIR=./build/bin -OBJDIR=./build/obj +BINDIR=build/bin +OBJDIR=build/obj BOOTDIR=boot -COMMDIR=kaleid/common +COMMDIR=kaleid/crtlib KERNDIR=kaleid/kernel SYSTDIR=kaleid/system -LINXDIR=kaleid/common/test +LINXDIR=kaleid/test //----------------------------------------------------------------------------# // TESTING MAKEFILE @@ -46,10 +63,10 @@ testing: bootloader pseudo_kern COBJDIR=$(OBJDIR)/$(COMMDIR) LOBJDIR=$(OBJDIR)/$(LINXDIR) -COMMOBJS=COBJ6(string, status, rand, memory, arith, strtol) COBJ4(itoa, ltoa, utoa, ultoa) COBJ4(atoi, atol, atou, atoul) +COMMOBJS=COBJ6(string, status, rand, memory, arith, strtol) COBJ4(itoa, ltoa, utoa, ultoa) COBJ4(atoi, atol, atou, atoul) COBJ2(../extras/prog, ../extras/argv) TCC=$(CC2NAME) $(COPTIM) $(CWARNS) $(CINCLUDES) -KCC=$(CC) -T ./build/kernel.ld -D_OSK_SOURCE -D_KALEID_KERNEL +KCC=$(CC) -D_KALEID_KERNEL comm-convert: COMPILE_CONVRT1(itoa) -D_NEED_ITOA @@ -68,23 +85,27 @@ common: comm-convert COMPILE_COMMON(status) COMPILE_COMMON(memory) COMPILE_COMMON(strtol) + COMPILE_COMMON(../extras/prog) + COMPILE_COMMON(../extras/argv) tests: common $(TCC) -c $(LINXDIR)/test-common.c -o $(LOBJDIR)/test-common.o - $(TCC) $(COMMOBJS) $(LOBJDIR)/test-common.o -o $(BINDIR)/kaleid-common.elf + $(TCC) $(COMMOBJS) $(LOBJDIR)/test-common.o -o $(BINDIR)/comm-test //----------------------------------------------------------------------------# // KERNEL MAKEFILE KOBJDIR=$(OBJDIR)/$(KERNDIR) -KERNOBJS=KOBJ4(init/init, init/table, ke/panic, ke/terminal) +KERNOBJS=KOBJ6(init/init, init/table, ke/panic, io/term, io/cursor, io/vga) kernel: common COMPILE_KERNEL(init/init) COMPILE_KERNEL(init/table) COMPILE_KERNEL(ke/panic) - COMPILE_KERNEL(ke/terminal) + COMPILE_KERNEL(io/cursor) + COMPILE_KERNEL(io/term) + COMPILE_KERNEL(io/vga) LINK_KERNEL(kaleid-kernel.elf) //----------------------------------------------------------------------------# diff --git a/ProjectTree b/ProjectTree index 965face..586b9d7 100644 --- a/ProjectTree +++ b/ProjectTree @@ -1,107 +1,110 @@ -#------------------------------------------------------------------------------# -# GNU GPL OS/K # +#=----------------------------------------------------------------------------=# +# GNU GPL OS/K # # # -# Authors: spectral` # -# NeoX # +# Desc: Project Tree # # # -# Desc: Project Tree # -#------------------------------------------------------------------------------# +# # +# 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 . # +#=----------------------------------------------------------------------------=# -src/ - | - x COPYING - x README.md - x ChangeLog - | - - Makefile - - Makefile.in - | - + boot/ - | | - | x folder.desc - | | - | - mbr.asm - | - mbr.inc - | | - | - loader.asm - | - loader16.inc - | - loader64.inc - | | - | 0 - | - + kaleid/ - | | - | + include/ - | | | - | | - kaleid.h - | | - kalkern.h - | | | - | | + common/ - | | | | - | | | - kaldefs.h - | | | - kaltypes.h - | | | - kalerror.h - | | | - kalassrt.h - | | | - kallims.h - | | | - kalmask.h - | | | - kalcrt.h - | | | | - | | | 0 - | | | - | | + kernel/ - | | | | - | | | - kernbase.h - | | | - kernlocks.h - | | | - kernterm.h - | | | | - | | | 0 - | | 0 - | | - | | - | + kernel/ - | | | - | | + init/ - | | | | - | | | - init.c - | | | | - | | | 0 - | | | - | | + ke/ - | | | | - | | | - panic.c - | | | - table.c - | | | - terminal.c - | | | | - | | | 0 - | | 0 - | | - | + common/ - | | | - | | - status.c - | | | - | | - arith.c - | | - rand.c - | | | - | | - atoi.c - | | - itoa.c - | | - strtol.c - | | | - | | - memory.c - | | - string.c - | | - sprintf.c - | | | - | | 0 - | 0 - | - + build/ - | | - | - preproc.h - | - iddtool.h - | | - | - kernel.ld - | | - | + bin/ - | + obj/ - | | - | 0 - 0 + + +. +├── boot +│   ├── loader +│   │   ├── cpu +│   │   │   ├── cpu.asm +│   │   │   └── cpuid.asm +│   │   ├── elf +│   │   │   └── elf.c +│   │   ├── fs +│   │   │   └── fat.asm +│   │   ├── io +│   │   │   ├── ata.asm +│   │   │   ├── lmmem.asm +│   │   │   ├── lmterm.asm +│   │   │   ├── rmmem.asm +│   │   │   └── rmterm.asm +│   │   └── loader.asm +│   ├── mbr +│   │   ├── mbr.asm +│   │   └── mbr.inc +│   └── folder.desc +├── build +│   ├── idttool.py +│   ├── kernel.ld +│   └── preproc.h +├── kaleid +│   ├── crtlib +│   │   ├── arith.c +│   │   ├── atoi.c +│   │   ├── itoa.c +│   │   ├── memory.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 +│   │   │   ├── sched.h +│   │   │   └── terminal.h +│   │   ├── kalbase.h +│   │   ├── kaleid.h +│   │   ├── kalext.h +│   │   └── kalkern.h +│   └── kernel +│   ├── init +│   │   ├── init.c +│   │   └── table.c +│   ├── io +│   │   ├── cursor.c +│   │   ├── term.c +│   │   └── vga.c +│   ├── ke +│   │   └── panic.c +│   └── proc +│   ├── Makefile +│   └── sched.c +├── AUTHORS +├── ChangeLog +├── COPYING +├── Makefile +├── Makefile.in +├── ProjectTree +└── Readme.md + +20 directories, 61 files diff --git a/Readme.md b/Readme.md index 0775db9..251d36e 100644 --- a/Readme.md +++ b/Readme.md @@ -1,14 +1,17 @@ -# GNU-GPL OS/K (OS on Kaleid) +# GNU GPL OS/K (OS on Kaleid) -### Fully open-source operating system from scratch (WIP), released under the GNU GPL version 3.0 +| ![FSF Logo](https://www.os-k.eu/GPLLOGO.PNG) | This program is free software, released under the terms of the [GNU GPL](COPYING) version 3 or later as published by the Free Software Foundation | +|----------------------------------------------|----------------------------------------------------------------------| -#### Boot Branch +### Fully free operating system from scratch (WIP) + +#### Master Branch For the project plan, see [OS/K Project](https://github.com/orgs/os-k-team/projects/1) -For changelog, see [ChangeLog](https://github.com/os-k-team/GNU-GPL-OS-K/blob/master/ChangeLog) +For changelog, see [ChangeLog](ChangeLog) -For structure of the sources, see [ProjectTree](https://github.com/os-k-team/GNU-GPL-OS-K/blob/master/ProjectTree) +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. +tabulation being 4 spaces long. diff --git a/_config.yml b/_config.yml new file mode 100644 index 0000000..c741881 --- /dev/null +++ b/_config.yml @@ -0,0 +1 @@ +theme: jekyll-theme-slate \ No newline at end of file diff --git a/boot/folder.desc b/boot/folder.desc index 6322bc3..fc76abf 100644 --- a/boot/folder.desc +++ b/boot/folder.desc @@ -1,11 +1,26 @@ ---------------------------------------------------------------------- - GNU GPL OS/K - - Authors: spectral` - NeoX - - Desc: Folder description - "boot" ---------------------------------------------------------------------- +#=----------------------------------------------------------------------------=# +# GNU GPL OS/K # +# # +# Desc: Folder description - "boot" # +# # +# # +# 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 . # +#=----------------------------------------------------------------------------=# This folder contains the source for OS/K's bootloader. @@ -19,5 +34,5 @@ It is divided in two parts each of exactly 512 bytes: The MBR must be placed precisely on the first sector of the hard drive. - loader.s - This is the Kernel Loader. XXX + This is the Kernel Loader. It switches to long mode and makes stuff. diff --git a/boot/loader/cpu/cpu.asm b/boot/loader/cpu/cpu.asm index e9b5274..b875758 100644 --- a/boot/loader/cpu/cpu.asm +++ b/boot/loader/cpu/cpu.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic longmode CPU functions ; -; (x86_64 architecture only) ; +; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 64] diff --git a/boot/loader/cpu/cpuid.asm b/boot/loader/cpu/cpuid.asm index ac82eff..89c1bde 100644 --- a/boot/loader/cpu/cpuid.asm +++ b/boot/loader/cpu/cpuid.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic realmode CPU Detection ; -; (x86_64 architecture only) ; +; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 16] diff --git a/boot/loader/elf/elf.c b/boot/loader/elf/elf.c index c30d834..fe48cde 100644 --- a/boot/loader/elf/elf.c +++ b/boot/loader/elf/elf.c @@ -1,10 +1,26 @@ -//----------------------------------------------------------------------------// +//=--------------------------------------------------------------------------=// // GNU GPL OS/K // // // -// Authors: spectral` // -// NeoX // -// // // Desc: ELF64 Parser and Loader // -//----------------------------------------------------------------------------// +// (x86_64 architecture only) // +// // +// // +// 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 . // +//=--------------------------------------------------------------------------=// int stub; diff --git a/boot/loader/fs/fat.asm b/boot/loader/fs/fat.asm index d9bca9b..978d7ed 100644 --- a/boot/loader/fs/fat.asm +++ b/boot/loader/fs/fat.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic File Allocation Table Long mode Driver ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 64] diff --git a/boot/loader/io/ata.asm b/boot/loader/io/ata.asm index f075b7d..c37cfc6 100644 --- a/boot/loader/io/ata.asm +++ b/boot/loader/io/ata.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic Read Only ATA Long mode Driver ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 64] diff --git a/boot/loader/io/lmmem.asm b/boot/loader/io/lmmem.asm index a82330e..e77e4c2 100644 --- a/boot/loader/io/lmmem.asm +++ b/boot/loader/io/lmmem.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic Memory Long mode Functions ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 64] diff --git a/boot/loader/io/lmterm.asm b/boot/loader/io/lmterm.asm index 427ae89..c5805d8 100644 --- a/boot/loader/io/lmterm.asm +++ b/boot/loader/io/lmterm.asm @@ -1,13 +1,29 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic Colored VGA Terminal Long mode Driver ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; + ;;VIDEO %define TRAM 0x0B8000 ; [T]ext[RAM] %define VRAM 0x0A0000 ; [V]ideo[RAM] diff --git a/boot/loader/io/rmmem.asm b/boot/loader/io/rmmem.asm index 2348083..865b9a9 100644 --- a/boot/loader/io/rmmem.asm +++ b/boot/loader/io/rmmem.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic Memory Realmode Driver ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 16] diff --git a/boot/loader/io/rmterm.asm b/boot/loader/io/rmterm.asm index 62f1b8a..275ff71 100644 --- a/boot/loader/io/rmterm.asm +++ b/boot/loader/io/rmterm.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Basic realmode terminal functions ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; [BITS 16] diff --git a/boot/loader/loader.asm b/boot/loader/loader.asm index c67f038..6734aec 100644 --- a/boot/loader/loader.asm +++ b/boot/loader/loader.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; ; GNU GPL OS/K ; ; ; -; Authors: spectral` ; -; NeoX ; -; ; ; Desc: Kernel (second stage) Loader for OS/K ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; %define DEBUG @@ -242,4 +257,3 @@ main64: jmp Die -times 20 db 0 diff --git a/boot/mbr/mbr.asm b/boot/mbr/mbr.asm index f94c713..1a08f74 100644 --- a/boot/mbr/mbr.asm +++ b/boot/mbr/mbr.asm @@ -1,11 +1,26 @@ ;=----------------------------------------------------------------------------=; -; GNU GPL OS/K ; -; ; -; Authors: spectral` ; -; NeoX ; +; GNU GPL OS/K ; ; ; ; Desc: Bootsector for OS/K ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; ;; BOOT "SEGMENT" diff --git a/boot/mbr/mbr.inc b/boot/mbr/mbr.inc index a5f396d..b006cce 100644 --- a/boot/mbr/mbr.inc +++ b/boot/mbr/mbr.inc @@ -1,12 +1,28 @@ ;=----------------------------------------------------------------------------=; -; GNU GPL OS/K ; -; ; -; Authors: spectral` ; -; NeoX ; +; GNU GPL OS/K ; ; ; ; Desc: Bootsector for OS/K INCLUDED FUNCTIONS ; ; (x86_64 architecture only) ; +; ; +; ; +; 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 . ; ;=----------------------------------------------------------------------------=; + [BITS 16] read_clusters: diff --git a/build/bin/comm-test b/build/bin/comm-test new file mode 100755 index 0000000..ea0cd8f Binary files /dev/null and b/build/bin/comm-test differ diff --git a/build/obj/kaleid/crtlib/.placeholder b/build/obj/kaleid/crtlib/.placeholder new file mode 100644 index 0000000..e69de29 diff --git a/build/obj/kaleid/crtlib/test/.paceholder b/build/obj/kaleid/crtlib/test/.paceholder new file mode 100644 index 0000000..e69de29 diff --git a/build/obj/kaleid/extras/.placeholder b/build/obj/kaleid/extras/.placeholder new file mode 100644 index 0000000..e69de29 diff --git a/build/obj/kaleid/test/.placeholder b/build/obj/kaleid/test/.placeholder new file mode 100644 index 0000000..e69de29 diff --git a/build/preproc.h b/build/preproc.h index f690c6e..746bd2c 100644 --- a/build/preproc.h +++ b/build/preproc.h @@ -9,11 +9,13 @@ #ifdef _TO_ASM # define _CSPREF -S # define _OUTFIX S +# define _ASMTYPE -masm=intel # define LINK_KERNEL(out) #else # define _CSPREF -c # define _OUTFIX o -# define LINK_KERNEL(out) $(KCC) $(CLDSCR) $(COMMOBJS) $(KERNOBJS) -o $(BINDIR)/out +# define _ASMTYPE +# define LINK_KERNEL(out) $(KCC) -T ./build/kernel.ld $(CLDSCR) $(COMMOBJS) $(KERNOBJS) -o $(BINDIR)/out #endif #define COMPILE_CONVRT1(file) $(CCC) _CSPREF $(COMMDIR)/itoa.c -o $(COBJDIR)/file._OUTFIX diff --git a/kaleid/common/arith.c b/kaleid/crtlib/arith.c similarity index 95% rename from kaleid/common/arith.c rename to kaleid/crtlib/arith.c index 5ac8338..68e2575 100644 --- a/kaleid/common/arith.c +++ b/kaleid/crtlib/arith.c @@ -8,8 +8,8 @@ //----------------------------------------------------------------------------// // do not mask anything -#define _KALMASK_H -#include +#define _KALEID_UNMASKED +#include int _osk_abs(int x) { diff --git a/kaleid/common/atoi.c b/kaleid/crtlib/atoi.c similarity index 98% rename from kaleid/common/atoi.c rename to kaleid/crtlib/atoi.c index 0ea016c..7066c55 100644 --- a/kaleid/common/atoi.c +++ b/kaleid/crtlib/atoi.c @@ -7,12 +7,10 @@ // Desc: Conversion utilities - atoi family // //----------------------------------------------------------------------------// -#include +#include -// // String to integer // Do not change errno -// #define _ATOI_IMPL(_Name, _Type, _Func) \ _Type _Name(const char *str) { \ __get_errno(old); \ diff --git a/kaleid/common/itoa.c b/kaleid/crtlib/itoa.c similarity index 93% rename from kaleid/common/itoa.c rename to kaleid/crtlib/itoa.c index a5e3383..67572e1 100644 --- a/kaleid/common/itoa.c +++ b/kaleid/crtlib/itoa.c @@ -7,54 +7,56 @@ // Desc: Conversion utilities - itoa family // //----------------------------------------------------------------------------// -#include +#include -// // Digits table for bases <=36 (unused) -// +#if 0 static const char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz"; +#endif // // Integer to string in any base between 2 and 36 (included) // - #if defined(_NEED_ITOA) -char *itoa(int i, char *str, int base) #define _IL_MIN INT_MIN #define _IL_MIN_STRING "-2147483648" +char *itoa(int i, char *str, int base) +{ + int rem; #elif defined(_NEED_LTOA) -char *ltoa(long i, char *str, int base) #define _IL_MIN LONG_MIN #define _IL_MIN_STRING "-9223372036854775808" +char *ltoa(long i, char *str, int base) +{ + long rem; #elif defined(_NEED_UTOA) char *utoa(uint i, char *str, int base) +{ + uint rem; #elif defined(_NEED_ULTOA) char *ultoa(ulong i, char *str, int base) +{ + ulong rem; #else #error "What am I supposed to declare?" #endif - -{ char *orig = str; #if defined(_NEED_ITOA) || defined(_NEED_LTOA) - // // Deal with negatives - // int neg = 0; if (i < 0 && base == 10) { - // + // Handle INT_MIN and LONG_MIN... - // if (__builtin_expect(i == _IL_MIN, 0)) { strcpy(orig, _IL_MIN_STRING); goto leave; @@ -67,27 +69,21 @@ char *ultoa(ulong i, char *str, int base) } #endif - // // Only handle base 2 -> 36 - // if (base < 2 || base > 36) { __set_errno(EINVAL); - *orig = '\0; + *orig = '\0'; goto leave; } - // // Deal with zero separately - // if (i == 0) { *str++ = '0'; *str = '\0'; goto leave; } - // // Compute digits... in reverse order - // while (i > 0) { rem = i % base; *str++ = (rem > 9) @@ -102,14 +98,10 @@ char *ultoa(ulong i, char *str, int base) *str = '\0'; - // // Reverse the string - // orig = strrev2(orig); - // // End of conversion - // leave: return orig; } diff --git a/kaleid/common/memory.c b/kaleid/crtlib/memory.c similarity index 83% rename from kaleid/common/memory.c rename to kaleid/crtlib/memory.c index 20a9dd2..ee31348 100644 --- a/kaleid/common/memory.c +++ b/kaleid/crtlib/memory.c @@ -7,7 +7,7 @@ // Desc: mem*() functions // //----------------------------------------------------------------------------// -#include +#include //------------------------------------------// // memset() family // @@ -20,17 +20,13 @@ void *memset(void *ptr, int val, size_t bytes) { uchar *uptr = (uchar *)ptr; - // // Deal with bytes before start of the first aligned qword - // - while (((ulong)uptr % QWORD_ALIGN) > 0 && bytes--) { + while (((ulong)uptr % alignof(QWORD)) > 0 && bytes--) { *uptr++ = (uchar)val; } - // // At this point we're qword-aligned - // - if (bytes > QWORD_SIZE) { + if (bytes > sizeof(QWORD)) { const ulong uval = ((ulong)val << 56) | ((ulong)val << 48) | ((ulong)val << 40) | ((ulong)val << 32) | ((ulong)val << 24) | ((ulong)val << 16) @@ -38,20 +34,16 @@ void *memset(void *ptr, int val, size_t bytes) ulong *uqptr = (ulong *)ptr; - // // Moving fast, qword by qword - // - while (bytes > QWORD_SIZE) { + while (bytes > sizeof(QWORD)) { + bytes -= sizeof(QWORD); *uqptr++ = uval; - bytes -= QWORD_SIZE; } uptr = (uchar *)(ulong)uqptr; } - // // Deal with the few remaining bytes - // while (bytes--) *uptr++ = (uchar)val; return ptr; @@ -64,18 +56,14 @@ void *memsetw(void *ptr, int val, size_t words) { ushort *uptr = (ushort *)ptr; - // - // Check whether we can we do this an aligned way - // - if unlikely (((ulong)uptr % WORD_ALIGN) > 0) { - // + // Check whether we can we do this a word-aligned way + if unlikely (((ulong)uptr % alignof(WORD)) > 0) { // We can't, so we write word by word all the way up - // while (words--) *uptr++ = (ushort)val; return uptr; } - while (((ulong)uptr % QWORD_ALIGN) > 0 && words--) { + while (((ulong)uptr % alignof(QWORD)) > 0 && words--) { *uptr++ = (ushort)val; } @@ -98,28 +86,22 @@ void *memsetw(void *ptr, int val, size_t words) return ptr; } -// // Set "dwords"-many dwords starting from ptr to val // XXX unimplemented -// void *memsetd(void *ptr, int val, size_t dwords) { (void)val; (void)dwords; - + __set_errno(ENOSYS); return ptr; } -// // Set "qwords"-many qwords starting from ptr to val -// void *memsetq(void *ptr, long val, size_t qwords) { ulong *uptr = (ulong *)ptr; - // // There's no need to check for alignment - // while (qwords--) *uptr++ = (ulong)val; return ptr; @@ -148,17 +130,13 @@ void *memcpy(void *restrict dst, const void *restrict src, size_t bytes) if unlikely (bytes == 0) return dst; - // // Can align both src and dst at once at once? - // - if unlikely ((ulong)src % WORD_ALIGN == 1 - && (ulong)dst % WORD_ALIGN == 1) { + if unlikely ((ulong)src % alignof(WORD) == 1 + && (ulong)dst % alignof(WORD) == 1) { const uchar *ubsrc = (const uchar *)usrc; uchar *ubdst = (uchar *)udst; - // - // Yes we can, we're guaranteed to be word-aligned now - // + // Yes we can, we're guaranteed to be word-aligned after that *ubdst++ = *ubsrc++; bytes--; @@ -169,34 +147,28 @@ void *memcpy(void *restrict dst, const void *restrict src, size_t bytes) const ushort *uwsrc = (const ushort *)usrc; ushort *uwdst = (ushort *)udst; - // // Align either dst or src for qword access - // - while ((ulong)dst % QWORD_ALIGN > 0 - && (ulong)src % QWORD_ALIGN > 0 - && bytes > WORD_SIZE) { + while ((ulong)dst % alignof(QWORD) > 0 + && (ulong)src % alignof(QWORD) > 0 + && bytes > sizeof(WORD)) { + bytes -= sizeof(WORD); *uwdst++ = *uwsrc++; - bytes -= WORD_SIZE; } udst = (ulong *)uwdst; usrc = (ulong *)uwsrc; - // - // This should be most of the job - // - while (bytes > QWORD_SIZE) { + // Copy fast + while (bytes > sizeof(QWORD)) { + bytes -= sizeof(QWORD); *udst++ = *usrc++; - bytes -= QWORD_SIZE; } const uchar *ubsrc = (const uchar *)usrc; ushort *ubdst = (ushort *)udst; - // // Deal with the few bytes left - // while (bytes--) *ubdst ++ = *ubsrc++; return dst; @@ -210,16 +182,12 @@ void *memmove(void *dst, const void *src, size_t bytes) const uchar *usrc = src; uchar *udst = dst; - // // Can we use memcpy() safely? - // if (udst < usrc) { return memcpy(dst, src, bytes); } - // // No, so we go backwards - // uchar *usrc_end = (uchar *)usrc + bytes - 1; uchar *udst_end = udst + bytes - 1; while (bytes--) *udst_end-- = *usrc_end--; diff --git a/kaleid/common/rand.c b/kaleid/crtlib/rand.c similarity index 89% rename from kaleid/common/rand.c rename to kaleid/crtlib/rand.c index fe576ef..186311f 100644 --- a/kaleid/common/rand.c +++ b/kaleid/crtlib/rand.c @@ -7,7 +7,7 @@ // Desc: RNG related functions // //----------------------------------------------------------------------------// -#include +#include // // Seed value @@ -20,8 +20,8 @@ static ulong next = 7756; // int rand(void) { - next = next * 1103515245 + 12345; - return (uint)(next / 65536) % INT_MAX; + next = next * 1103515245 + 12347; + return (uint)(next / 65536); } // diff --git a/kaleid/common/sprintf.c b/kaleid/crtlib/sprintf.c similarity index 92% rename from kaleid/common/sprintf.c rename to kaleid/crtlib/sprintf.c index a8dd3ba..c3ad3f1 100644 --- a/kaleid/common/sprintf.c +++ b/kaleid/crtlib/sprintf.c @@ -7,11 +7,14 @@ // Desc: sprintf()-related functions // //----------------------------------------------------------------------------// -#include +#include // // Format str according to fmt using ellipsed arguments // +// BE CAREFUL when using this +// you need to know for sure an overflow won't happen +// int sprintf(char *str, const char *fmt, ...) { int ret; @@ -31,6 +34,7 @@ int vsprintf(char *str, const char *fmt, va_list ap) // // (v)sprintf() but with a size limit: no more than n bytes are written in str +// Always null-terminate str // int snprintf(char *str, size_t n, const char *fmt, ...) { @@ -48,14 +52,10 @@ int vsnprintf(char *str, size_t n, const char *fmt, va_list ap) { int ret = 0; - // // Go throught the format string - // while (*fmt) { if (*fmt != '%') { - // // Even if we don't have any more room we still increase ret - // if (ret++ < n) { *str++ = *fmt++; } diff --git a/kaleid/common/status.c b/kaleid/crtlib/status.c similarity index 98% rename from kaleid/common/status.c rename to kaleid/crtlib/status.c index 2866833..6fc3c38 100644 --- a/kaleid/common/status.c +++ b/kaleid/crtlib/status.c @@ -7,7 +7,7 @@ // Desc: Implementation of describe_status() // //----------------------------------------------------------------------------// -#include +#include error_t __errno = 0; diff --git a/kaleid/common/string.c b/kaleid/crtlib/string.c similarity index 84% rename from kaleid/common/string.c rename to kaleid/crtlib/string.c index d7c391d..d9d6776 100644 --- a/kaleid/common/string.c +++ b/kaleid/crtlib/string.c @@ -7,8 +7,7 @@ // Desc: String-related functions // //----------------------------------------------------------------------------// - -#include +#include // // Compare two strings @@ -129,9 +128,7 @@ char *strstr(const char *haystack, const char *needle) { const size_t needle_size = strlen(needle); - // // Moves haystack to first occurence of the needle's first byte - // while ((haystack = strchr(haystack, *needle)) != NULL) { if (strncmp(haystack, needle, needle_size) == 0) { return (char *)haystack; @@ -151,15 +148,11 @@ char *strtok_r(char *restrict str, const char *restrict delim, char **restrict s if (str == NULL) str = *saveptr; - // // Skip initial segments composed only of delimiters - // str += strspn(str, delim); - // // If str is empty, store it in saveptr so that next call // still finds an empty strings and returns NULL - // if (*str == 0) { *saveptr = str; return NULL; @@ -192,6 +185,7 @@ char *strtok(char *restrict str, const char *restrict delim) { static char *saveptr = NULL; + // Avoid this function if possible KalAssert(FALSE); if (str) saveptr = str; @@ -229,33 +223,26 @@ char *strncpy(char *restrict dest, const char *restrict src, size_t n) } // -// Copies at most n-1 bytes from src to dest, then fills -// the rest with 0; dest[n] is guanranteed to be '\0' +// Copies at most n-1 bytes from src to dest +// Always null-terminates dest, but doesn't fill +// dest's contents past the null-terminator // -// Returns TRUE if dest would have been null-terminated -// by ordinary strncpy(), and FALSE otherwise +// Returns the number of bytes NOT written, not counting null-terminators // -int strnzcpy(char *restrict dest, const char *restrict src, size_t n) +size_t strnzcpy(char *restrict dest, const char *restrict src, size_t n) { - size_t it; + size_t it, loss; for (it = 0; it < n - 1 && src[it]; it++) { dest[it] = src[it]; } - // Was the copy complete? - if (it == n) { - if (dest[n] == 0) { - return TRUE; - } + dest[it] = 0; - dest[n] = 0; - return FALSE; - } + // Compute how many bytes were not copied + for (loss = it; src[loss]; loss++); - while (it < n) dest[it++] = 0; - - return TRUE; + return loss - it; } // @@ -288,13 +275,15 @@ char *strncat(char *restrict dest, const char *restrict src, size_t n) } // -// Appends a copy of at most n bytes of src at the end of dest -// Always null-terminates, and returne TRUE or FALSE depending on whether -// regular strcat() would have null-terminated this string, or not +// Appends at most n-1 bytes from src to dest +// Always null-terminates dest, but doesn't fill +// dest's contents past the null-terminator // -int *strnzcat(char *restrict dest, const char *restrict src, size_t n) +// Returns the number of bytes NOT written, not counting null-terminators +// +size_t strnzcat(char *restrict dest, const char *restrict src, size_t n) { - size_t it, off = 0; + size_t it, loss, off = 0; while (dest[off]) off++; @@ -302,19 +291,12 @@ int *strnzcat(char *restrict dest, const char *restrict src, size_t n) dest[it+off] = src[it]; } - // Was the copy complete? - if (it == n) { - if (dest[n+off] == 0) { - return TRUE; - } + dest[it+off] = 0; - dest[n+off] = 0; - return FALSE; - } + // Compute how many bytes were not copied + for (loss = it; src[loss+off]; loss++); - while (it++ < n) dest[it+off] = 0; - - return TRUE; + return loss - it; } // diff --git a/kaleid/common/strtol.c b/kaleid/crtlib/strtol.c similarity index 97% rename from kaleid/common/strtol.c rename to kaleid/crtlib/strtol.c index 7636822..87a132f 100644 --- a/kaleid/common/strtol.c +++ b/kaleid/crtlib/strtol.c @@ -7,7 +7,7 @@ // Desc: strto(u)l functions // //----------------------------------------------------------------------------// -#include +#include long strtol(const char *str, char **endp, int base) { (void)str; diff --git a/kaleid/extras/argv.c b/kaleid/extras/argv.c new file mode 100644 index 0000000..d9920da --- /dev/null +++ b/kaleid/extras/argv.c @@ -0,0 +1,202 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Command line parsing utilities // +//----------------------------------------------------------------------------// + +#include +#include +#include +#include + +// +// Computes argument count, the least N such +// that argv[N] == NULL +// +int KalComputeArgCount(const char **argv) +{ + int argc = 0; + + while (argv[argc]) argc++; + + return argc; +} + +// +// Computes the total size of argv, including +// the null-terminators +// +size_t KalComputeArgVecSize(const char *argv[]) +{ + size_t len; + + for (len = 0; *argv; len += strlen(*argv) + 1, argv++); + + return len; +} + +// +// Converts command line to an argument vector +// +// This function assumes that argv[0] is a pointer +// to a ARG_MAX-wide buffer, which will be filled +// with strings in succession; the address of the nth +// string will be stored in argv[n-1] +// +// Technically ARG_MAX is the maximum number of bytes +// in both the buffer *and* argv, i.e. (argc + 1) * sizeof(char *) +// bytes are reserved for the argv[i] pointers, so in fact less than +// ARG_MAX bytes are available +// +// That available space, however, remains strictly higher than 4KB, +// which is the POSIX minimum; in case of doubt, safely use 4KB +// +// TODO long escape sequences +// get program command line if cmdLine == NULL +// +error_t KalCmdLineToArgVecEx(const char *cmdLine, + int *argcPtr, + char **argv, + bool doEscaping) +{ + int argc; + char quotes = 0; + bool started = false; + bool escaping = false; + size_t written = 0; + error_t retcode = EOK; + + KalAlwaysAssert(argv && *argv && cmdLine); + + // An ARG_MAX-wide buffer + char *buffer = *argv; + + // Null-terminate current argv slot + // and save the start of next string + // Macro'd to avoid copypasting code +#define NULLTERM_AND_SAVE \ + *buffer = 0; \ + argv[++argc] = buffer++ + 1; \ + written += sizeof(char *) + 1; \ + + // Is character a blank character? + // To be replaced by ctype stuff once + // that's implemented +#define ISBLANK(c) ((c) == ' ' || (c) == '\t' || (c) == '\n') + + // Both " and ' are valid quotes chars + // XXX aren't there more? +#define ISQUOTE(c) ((c) == '\'' || (c) == '"') + + + // Go through the command line + for (argc = 0; *cmdLine; cmdLine++) { + + // Make sure we don't go beyond ARG_MAX bytes + if (written >= ARG_MAX - (1 + sizeof(char *))) { + + // All we have left is one byte for the null-terminator of the current slot + // and sizeof(char *) bytes for the NULL at the end of argv + *buffer = 0; + + // Did we write anything in this slot? + if (started) { + argc++; + } + + // We're done, get out of here + retcode = ENOMEM; + break; + } + + // Switch to next argv slot + if (ISBLANK(*cmdLine) && !quotes && !escaping) { + + // Has slot even started? + if (started) { + started = false; + NULLTERM_AND_SAVE; + } + + continue; + } + + // Escaping next character + if (*cmdLine == '\\' && !escaping && doEscaping) { + escaping = true; + continue; + } + + // Deal with escape sequences + if (escaping) { + if (*cmdLine == 'n') *buffer++ = '\n'; + else if (*cmdLine == 'r') *buffer++ = '\r'; + else if (*cmdLine == 't') *buffer++ = '\t'; + else if (*cmdLine == 'f') *buffer++ = '\f'; + else if (*cmdLine == 'v') *buffer++ = '\v'; + + written++; + started = true; + escaping = false; + continue; + } + + // Deal with quotes + if (ISQUOTE(*cmdLine) && !escaping) { + + // Quoted text always fills a whole slot + // Note that this is the only way an empty + // string can be put in a slot + if (!quotes && !started) { + quotes = *cmdLine; + started = true; + + continue; + } + + // End a quote block + if (quotes == *cmdLine && ISBLANK(cmdLine[1])) { + quotes = 0; + started = false; + + NULLTERM_AND_SAVE; + continue; + } + + // Quotes were either preceeded by unquoted non-blank text + // or couldn't close quoted text block because succeeded + // by text; we consider this " to be escaped and fall through + } + + // Just a regular character, or it is being escaped + written++; + started = true; + escaping = false; + *buffer++ = *cmdLine; + } + + // Ensures that argv[argc] == NULL + argv[++argc] = NULL; + + // Update *argcPtr, but we don't mind if + // NULL was passed for argcPtr + if (argcPtr) { + *argcPtr = argc; + } + + return retcode; +} + +#undef ISQUOTE +#undef ISBLANK +#undef NULLTERM_AND_SAVE + +error_t KalCmdLineToArgVec(const char *cmdLine, + int *argcPtr, + char **argv) +{ + return KalCmdLineToArgVecEx(cmdLine, argcPtr, argv, false); +} diff --git a/kaleid/extras/prog.c b/kaleid/extras/prog.c new file mode 100644 index 0000000..b0ce13d --- /dev/null +++ b/kaleid/extras/prog.c @@ -0,0 +1,48 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Program utilities // +//----------------------------------------------------------------------------// + +#include +#include + +#ifdef _KALEID_KERNEL + +const char *__progname = "kaleid-kernel"; +const char *__progvers = "pre-pre-alpha-0.0.1"; + +#else + +const char *__progname = "kaleid-test"; +const char *__progvers = "(n/a)"; + +#endif + +const char *KalGetProgName(void) +{ + return __progname; +} + +const char *KalGetProgVersion(void) +{ + return __progvers; +} + +bool KalSetProgVers(const char *vers) +{ + (void)vers; + __set_errno(ENOSYS); + return false; +} + +bool KalSetProgName(const char *name) +{ + (void)name; + __set_errno(ENOSYS); + return false; +} + diff --git a/kaleid/include/common/kalassrt.h b/kaleid/include/base/assert.h similarity index 74% rename from kaleid/include/common/kalassrt.h rename to kaleid/include/base/assert.h index cf4ddbb..65d00da 100644 --- a/kaleid/include/common/kalassrt.h +++ b/kaleid/include/base/assert.h @@ -7,11 +7,9 @@ // Desc: Kaleid assert() support // //----------------------------------------------------------------------------// -#ifndef _KALASSRT_H -#define _KALASSRT_H +#ifndef _KALBASE_ASSERT_H +#define _KALBASE_ASSERT_H -//------------------------------------------// -// Macros // //------------------------------------------// #ifndef noreturn @@ -38,35 +36,39 @@ static_assert(sizeof(long) == 8, _SA_MSG); static_assert(sizeof(void *) == 8, _SA_MSG); #undef _SA_MSG +//------------------------------------------// +// Assert core // +//------------------------------------------// + +// Failed assert handler +noreturn void __assert_handler(const char *, const char *, int, const char *); + +// Unconditional assert +#define KalAlwaysAssert(x) \ + do { \ + if unlikely (!(x)) \ + __assert_handler(#x, __FILE__, __LINE__, __func__); \ + } while (0) + //------------------------------------------// // When debugging // //------------------------------------------// -#if !defined(_NO_DEBUG) && !defined(NDEBUG) && !defined(assert) - -#ifdef _OSK_SOURCE +#if !defined(_NO_DEBUG) && !defined(NDEBUG) && !defined(KalAssert) // -// Failed assert handler +// Check whether (x) holds, if not call __assert_handler // -noreturn void _assert_handler(const char *, const char *, int, const char *); +#define KalAssert KalAlwaysAssert -// -// Checks whether (x) holds, if not call _assert_handler -// -#define assert(x) \ - do { \ - if unlikely (!(x)) \ - _assert_handler(#x, __FILE__, __LINE__, __func__); \ - } while (0); +#ifndef _OSK_SOURCE -#else - -// // When not building for OS/K, use the system's assert -// #include +#undef KalAlwaysAssert +#define KalAlwaysAssert assert + #endif //------------------------------------------// @@ -83,26 +85,23 @@ noreturn void _assert_handler(const char *, const char *, int, const char *); #define _NO_DEBUG 1 #endif -#ifndef assert -#define assert(x) ((void)0) -#endif - -#endif - -//------------------------------------------// -// Aliases for assert() // -//------------------------------------------// - -#ifndef Assert -#define Assert assert -#endif - #ifndef KalAssert -#define KalAssert assert +#define KalAssert(x) ((void)0) +#endif + #endif //------------------------------------------// -// End of header // +// Aliases and extensions // +//------------------------------------------// + +#ifndef assert +#define assert KalAssert +#endif + +#define KalAssertEx(x,m) KalAssert(x && m) +#define KalAlwaysAssertEx(x,m) KalAlwaysAssert(x && m) + //------------------------------------------// #endif diff --git a/kaleid/include/common/kaldefs.h b/kaleid/include/base/bdefs.h similarity index 75% rename from kaleid/include/common/kaldefs.h rename to kaleid/include/base/bdefs.h index cc43ee9..9b3c4d4 100644 --- a/kaleid/include/common/kaldefs.h +++ b/kaleid/include/base/bdefs.h @@ -7,11 +7,9 @@ // Desc: Kaleid general preprocessor constants // //----------------------------------------------------------------------------// -#ifndef _KALDEFS_H -#define _KALDEFS_H +#ifndef _KALBASE_BDEFS_H +#define _KALDEFS_BDEFS_H -//------------------------------------------// -// Actual constants // //------------------------------------------// #ifndef TRUE @@ -26,8 +24,10 @@ #define NULL 0L #endif -//------------------------------------------// -// Keywords // +#ifndef INITOK +#define INITOK ((unsigned int)0xCAFEBABE) +#endif + //------------------------------------------// #ifndef __alignof_is_defined @@ -53,8 +53,6 @@ # endif #endif -//------------------------------------------// -// Attributes and macros // //------------------------------------------// #ifndef _PACKED @@ -81,16 +79,6 @@ #define _XSTR(x) _STR(x) #endif -//------------------------------------------// -// API specific macros // -//------------------------------------------// - -#ifndef KALAPI -# define KALAPI -#endif - -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/common/kalcrt.h b/kaleid/include/base/crtlib.h similarity index 77% rename from kaleid/include/common/kalcrt.h rename to kaleid/include/base/crtlib.h index 165ba90..47b269d 100644 --- a/kaleid/include/common/kalcrt.h +++ b/kaleid/include/base/crtlib.h @@ -7,11 +7,9 @@ // Desc: Kaleid C runtime library // //----------------------------------------------------------------------------// -#ifndef _KALCRT_H -#define _KALCRT_H +#ifndef _KALBASE_CRTLIB_H +#define _KALBASE_CRTLIB_H -//------------------------------------------// -// Typedefs // //------------------------------------------// #ifndef __error_t_defined @@ -39,8 +37,6 @@ typedef struct { int quot, rem; } div_t; typedef struct { long quot, rem; } ldiv_t; #endif -//------------------------------------------// -// Global variables // //------------------------------------------// #ifndef _KALEID_KERNEL @@ -62,16 +58,12 @@ extern error_t __errno; #endif -//------------------------------------------// -// Macros // //------------------------------------------// #ifndef _NO_MASK #define _NO_MASK #endif -//------------------------------------------// -// va_list utilities // //------------------------------------------// #ifndef va_start @@ -90,8 +82,6 @@ extern error_t __errno; #define va_end __builtin_va_end #endif -//------------------------------------------// -// Memory management utilities // //------------------------------------------// #ifndef memsetb @@ -107,10 +97,12 @@ void *memsetw(void *, int, size_t); void *memsetd(void *, int, size_t); void *memsetq(void *, long, size_t); +/* void *memchr(const void *, int, size_t); void *memchrw(const void *, int, size_t); void *memchrd(const void *, int, size_t); void *memchrq(const void *, long, size_t); +*/ void *memrchr(const void *, int, size_t); @@ -120,8 +112,6 @@ void *memmove(void *, const void *, size_t); void *memzero(void *, size_t); int memcmp(const void *, const void *, size_t); -//------------------------------------------// -// String manipulation utilities // //------------------------------------------// size_t strlen(const char *); @@ -143,11 +133,11 @@ char *strtok_r(char *restrict, const char *restrict, char **restrict); char *strcpy (char *restrict, const char *restrict); char *strncpy (char *restrict, const char *restrict, size_t); -int strnzcpy(char *restrict, const char *restrict, size_t); +size_t strnzcpy(char *restrict, const char *restrict, size_t); char *strcat (char *restrict, const char *restrict); char *strncat (char *restrict, const char *restrict, size_t); -int *strnzcat(char *restrict, const char *restrict, size_t); +size_t strnzcat(char *restrict, const char *restrict, size_t); char *strrev(char *restrict, const char *restrict); char *strrev2(char *); @@ -157,8 +147,6 @@ int snprintf(char *, size_t, const char *, ...); int vsprintf(char *, const char *, va_list); int vsnprintf(char *, size_t, const char *, va_list); -//------------------------------------------// -// Type conversion utilities // //------------------------------------------// char *itoa(int, char *, int); @@ -174,41 +162,31 @@ unsigned long atoul(const char *); long strtol (const char *restrict, char **restrict, int); unsigned long strtoul(const char *restrict, char **restrict, int); -//------------------------------------------// -// RNG utilities // //------------------------------------------// int rand(void); void srand(unsigned int); -//------------------------------------------// -// Time utilities // -//------------------------------------------// - -//------------------------------------------// -// Diverse utilities // //------------------------------------------// char *strerror(int); char *strsignal(int); -//------------------------------------------// -// Arithmetical macros // //------------------------------------------// #ifndef __abs #define __abs -static inline int abs(int x) +static inline int abs(int __x) { - return x < 0 ? -x : x; + return __x < 0 ? -__x : __x; } #endif #ifndef __labs #define __labs -static inline long labs(long x) +static inline long labs(long __x) { - return x < 0 ? -x : x; + return __x < 0 ? -__x : __x; } #endif @@ -234,8 +212,6 @@ static inline ldiv_t ldiv(long __x, long __y) } #endif -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/common/kalerror.h b/kaleid/include/base/errno.h similarity index 87% rename from kaleid/include/common/kalerror.h rename to kaleid/include/base/errno.h index b29c660..f77c8f8 100644 --- a/kaleid/include/common/kalerror.h +++ b/kaleid/include/base/errno.h @@ -7,11 +7,9 @@ // Desc: Values for errno_t and errno // //----------------------------------------------------------------------------// -#ifndef _KALERROR_H -#define _KALERROR_H +#ifndef _KALBASE_ERRNO_H +#define _KALBASE_ERRNO_H -//------------------------------------------// -// "errno" values // //------------------------------------------// // Everything went fine @@ -44,6 +42,12 @@ // Bad file number #define EBADF 9 +// Try again +#define EAGAIN 11 + +// Out of memory +#define ENOMEM 12 + // Invalid argument #define EINVAL 22 @@ -56,8 +60,6 @@ // System is panicking #define EPANIC 600 -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/base/limits.h b/kaleid/include/base/limits.h new file mode 100644 index 0000000..56a03ee --- /dev/null +++ b/kaleid/include/base/limits.h @@ -0,0 +1,78 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Kaleid type limits definitions // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_LIMITS_H +#define _KALBASE_LIMITS_H + +//------------------------------------------// + +#define BYTE unsigned char +#define WORD unsigned short +#define DWORD unsigned int +#define QWORD unsigned long + +#define CHAR_BIT 8 +#define BITS_IN(T) (sizeof(T) * CHAR_BIT) + +/* XXX find a generic way */ +#define BYTES_TO_WORDS(B) ((B) >> 1) +#define BYTES_TO_DWORDS(B) ((B) >> 2) +#define BYTES_TO_QWORDS(B) ((B) >> 3) +#define WORDS_TO_BYTES(W) ((W) << 1) +#define WORDS_TO_DWORDS(W) ((W) >> 1) +#define WORDS_TO_QWORDS(W) ((W) >> 2) +#define DWORDS_TO_BYTES(D) ((D) << 2) +#define DWORDS_TO_WORDS(D) ((D) << 1) +#define DWORDS_TO_QWORDS(D) ((D) >> 1) +#define QWORDS_TO_BYTES(Q) ((Q) << 3) +#define QWORDS_TO_WORDS(Q) ((Q) << 2) +#define QWORDS_TO_DWORDS(Q) ((Q) << 1) + +//------------------------------------------// + +/* U/L suffixes on hex numbers look odd */ +#define SCHAR_MAX ((signed char) 0x7F) +#define SHRT_MAX ((short) 0x7FFF) +#define INT_MAX ((int) 0x7FFFFFFF) +#define LONG_MAX ((long) 0x7FFFFFFFFFFFFFFFL) +#define UCHAR_MAX ((unsigned char) 0xFFU) +#define USHRT_MAX ((unsigned short) 0xFFFFU) +#define UINT_MAX ((unsigned int) 0xFFFFFFFFU) +#define ULONG_MAX ((unsigned long) 0xFFFFFFFFFFFFFFFFUL) + +#define SCHAR_MIN ((signed char) -SCHAR_MAX - 1) +#define SHRT_MIN ((short) -SHRT_MAX - 1) +#define INT_MIN ((int) -INT_MAX - 1) +#define LONG_MIN ((long) -LONG_MAX - 1L) + +#ifdef __CHAR_UNSIGNED__ +# define CHAR_MIN ((char)0) +# define CHAR_MAX ((char)UCHAR_MAX) +#else +# define CHAR_MIN ((char)SCHAR_MIN) +# define CHAR_MAX ((char)SCHAR_MAX) +#endif + +#define SSIZE_T_MIN LONG_MIN +#define SSIZE_T_MAX LONG_MAX +#define SIZE_T_MAX ULONG_MAX + +#ifdef NEED_MORE_USELESS_DATA +# define UCHAR_MIN ((unsigned char)0) +# define USHRT_MIN ((unsigned short)0) +# define UINT_MIN ((unsigned int)0) +# define ULONG_MIN ((unsigned long)0) +# ifdef STILL_NEED_MORE_USELESS_DATA +# error "Not enough useless data!" +# endif +#endif + +//------------------------------------------// + +#endif diff --git a/kaleid/include/common/kalmask.h b/kaleid/include/base/masks.h similarity index 89% rename from kaleid/include/common/kalmask.h rename to kaleid/include/base/masks.h index c185354..868df80 100644 --- a/kaleid/include/common/kalmask.h +++ b/kaleid/include/base/masks.h @@ -7,8 +7,13 @@ // Desc: Masks for the functions in the KCRL // //----------------------------------------------------------------------------// -#ifndef _KALMASK_H -#define _KALMASK_H +#ifndef _KALBASE_MASKS_H +#define _KALBASE_MASKS_H + +//------------------------------------------// + +#define div_t _osk_div_t +#define ldiv_t _osk_ldiv_t //------------------------------------------// @@ -33,26 +38,40 @@ //------------------------------------------// +#undef strspn +#undef strcspn #define strlen _osk_strlen #define strspn _osk_strspn #define strcspn _osk_strcspn +#undef strcmp +#undef strncmp #define strcmp _osk_strcmp #define strncmp _osk_strncmp +#undef strchr +#undef strrchr #define strchr _osk_strchr #define strrchr _osk_strrchr +#undef strstr +#undef strpbrk #define strstr _osk_strstr #define strpbrk _osk_strpbrk +#undef strtok +#undef strtok_r #define strtok _osk_strtok #define strtok_r _osk_strtok_r +#undef strcpy +#undef strncpy #define strcpy _osk_strcpy #define strncpy _osk_strncpy #define strnzcpy _osk_strnzcpy +#undef strcat +#undef strncat #define strcat _osk_strcat #define strncat _osk_strncat #define strnzcat _osk_strnzcat @@ -67,7 +86,6 @@ //------------------------------------------// - #define itoa _osk_itoa #define ltoa _osk_ltoa #define utoa _osk_utoa @@ -107,8 +125,6 @@ #define strerror _osk_strerror -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/common/kaltypes.h b/kaleid/include/base/types.h similarity index 81% rename from kaleid/include/common/kaltypes.h rename to kaleid/include/base/types.h index 6823ddb..7e40d34 100644 --- a/kaleid/include/common/kaltypes.h +++ b/kaleid/include/base/types.h @@ -7,11 +7,9 @@ // Desc: Kaleid C common types // //----------------------------------------------------------------------------// -#ifndef _KALTYPES_H -#define _KALTYPES_H +#ifndef _KALBASE_TYPES_H +#define _KALBASE_TYPES_H -//------------------------------------------// -// Basic integer types aliases // //------------------------------------------// #ifndef __base_types_aliases @@ -26,8 +24,6 @@ typedef unsigned long long ullong; typedef long double ldouble; #endif -//------------------------------------------// -// Miscellaneous types // //------------------------------------------// #ifndef __size_t_defined @@ -50,8 +46,6 @@ typedef signed int wchar_t; typedef unsigned long off_t; #endif -//------------------------------------------// -// Standard fixed-width integer types // //------------------------------------------// #ifndef __ptrdiff_t_defined @@ -79,8 +73,6 @@ typedef signed long intmax_t; typedef unsigned long uintmax_t; #endif -//------------------------------------------// -// Special types // //------------------------------------------// #ifndef __va_list_defined @@ -99,8 +91,6 @@ typedef struct { long quot, rem; } ldiv_t; #endif -//------------------------------------------// -// Kaleid-specific types // //------------------------------------------// #ifndef __error_t_defined @@ -113,8 +103,6 @@ typedef int error_t; typedef ushort port_t; #endif -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/common/kallims.h b/kaleid/include/common/kallims.h deleted file mode 100644 index 9afd35d..0000000 --- a/kaleid/include/common/kallims.h +++ /dev/null @@ -1,117 +0,0 @@ -//----------------------------------------------------------------------------// -// GNU GPL OS/K // -// // -// Authors: spectral` // -// NeoX // -// // -// Desc: Kaleid type limits definitions // -//----------------------------------------------------------------------------// - -#ifndef _KALLIMS_H -#define _KALLIMS_H - -//------------------------------------------// -// Data sizes blocks // -//------------------------------------------// - -#ifndef DATA_SIZE_BLOCK -#define DATA_SIZE_BLOCK -# define BYTE_SIZE sizeof(char) -# define WORD_SIZE sizeof(short) -# define DWORD_SIZE sizeof(int) -# define QWORD_SIZE sizeof(long) -#endif - -#ifndef DATA_ALIGN_BLOCK -#define DATA_ALIGN_BLOCK -# define BYTE_ALIGN alignof(char) -# define WORD_ALIGN alignof(short) -# define DWORD_ALIGN alignof(int) -# define QWORD_ALIGN alignof(long) -#endif - -#ifndef DATA_BITS_BLOCK -#define DATA_BITS_BLOCK -# define BYTE_BIT 8 -# define CHAR_BIT (BYTE_SIZE * BYTE_BIT) -# define WORD_BIT (WORD_SIZE * BYTE_BIT) -# define DWORD_BIT (DWORD_SIZE * BYTE_BIT) -# define QWORD_BIT (QWORD_SIZE * BYTE_BIT) -# define SHORT_BIT WORD_BIT -# define INT_BIT DWORD_BIT -# define LONG_BIT QWORD_BIT -#endif - -#ifndef DATA_SHIFTS_BLOCK -#define DATA_SHIFTS_BLOCK -# define BYTES_TO_WORDS(B) ((B) >> 1) -# define BYTES_TO_DWORDS(B) ((B) >> 2) -# define BYTES_TO_QWORDS(B) ((B) >> 3) -# define WORDS_TO_BYTES(W) ((W) << 1) -# define WORDS_TO_DWORDS(W) ((W) >> 1) -# define WORDS_TO_QWORDS(W) ((W) >> 2) -# define DWORDS_TO_BYTES(D) ((D) << 2) -# define DWORDS_TO_WORDS(D) ((D) << 1) -# define DWORDS_TO_QWORDS(D) ((D) >> 1) -# define QWORDS_TO_BYTES(Q) ((Q) << 3) -# define QWORDS_TO_WORDS(Q) ((Q) << 2) -# define QWORDS_TO_DWORDS(Q) ((Q) << 1) -#endif - -//------------------------------------------// -// Numeric data limits // -//------------------------------------------// - -#ifndef DATA_MAX_LIMITS_BLOCK -#define DATA_MAX_LIMITS_BLOCK -# define SCHAR_MAX ((signed char) 0x7F) -# define SHRT_MAX ((short) 0x7FFF) -# define INT_MAX ((int) 0x7FFFFFFF) -# define LONG_MAX ((long) 0x7FFFFFFFFFFFFFFF) -# define UCHAR_MAX ((unsigned char) 0xFF -# define USHRT_MAX ((unsigned short) 0xFFFF) -# define UINT_MAX ((unsigned int) 0xFFFFFFFF) -# define ULONG_MAX ((unsigned long) 0xFFFFFFFFFFFFFFFF) -#endif - -#ifndef DATA_MIN_LIMITS_BLOCK -#define DATA_MIN_LIMITS_BLOCK -# define SCHAR_MIN ((signed char) -SCHAR_MAX - 1) -# define SHRT_MIN ((short) -SHRT_MAX - 1) -# define INT_MIN ((int) -INT_MAX - 1) -# define LONG_MIN ((long) -LONG_MAX - 1L) -#endif - -#ifndef DATA_CHAR_LIMITS_BLOCK -#define DATA_CHAR_LIMITS_BLOCK -# ifdef __CHAR_UNSIGNED__ -# define CHAR_MIN ((char)0) -# define CHAR_MAX ((char)UCHAR_MAX) -# else -# define CHAR_MIN ((char)SCHAR_MIN) -# define CHAR_MAX ((char)SCHAR_MAX) -# endif -#endif - -#ifndef DATA_SPTYPES_LIMITS_BLOCK -#define DATA_SPTYPES_LIMITS_BLOCK -# define SSIZE_T_MIN LONG_MIN -# define SSIZE_T_MAX LONG_MAX -# define SIZE_T_MAX ULONG_MAX -#endif - -#ifdef NEED_MORE_USELESS_DATA -# define UCHAR_MIN ((unsigned char)0) -# define USHRT_MIN ((unsigned short)0) -# define UINT_MIN ((unsigned int)0) -# define ULONG_MIN ((unsigned long)0) -# ifdef STILL_NEED_MORE_USELESS_DATA -# error "Not enough useless data!" -# endif -#endif - -//------------------------------------------// -// End of header // -//------------------------------------------// - -#endif diff --git a/kaleid/include/extras/argv.h b/kaleid/include/extras/argv.h new file mode 100644 index 0000000..2a1a22e --- /dev/null +++ b/kaleid/include/extras/argv.h @@ -0,0 +1,282 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Command line parsing utilities // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_H +#include +#endif + +#ifdef _KALEID_KERNEL +#define FILE FILE +typedef void* FILE; +#else +#include +#endif + +#ifndef _KALEXTRAS_ARGV_H +#define _KALEXTRAS_ARGV_H + +//------------------------------------------// + +// +// Maximal total size of argv, including the pointers, +// the pointed-to strings and their null-terminators +// This is a 32-bit integer +// +#define ARG_MAX (1 << 16) // 16 KB + +//------------------------------------------// + +// +// Flags for options +// +typedef enum { + + // The option parameter is optional + KALOPT_OPTIONAL = (1 << 0), + + // Do not show option in any help message + KALOPT_HIDDEN = (1 << 1), + + // This option is an alias for the previous one + KALOPT_ALIAS = (1 << 2), + + // This isn't an option but a docstring + KALOPT_DOCSTR = (1 << 3), + + // Only show in long help messages + KALOPT_LONGDOC = (1 << 4), + +} CmdOptionFlag_t; + +// +// Flags for KalParse(CmdLine|ArgV) +// +typedef enum { + + // Don't exit on errors= + KALOPT_NO_EXIT = (1 << 0), + + // Don't react to --help + KALOPT_NO_HELP = (1 << 1), + + // Don't react to --version + KALOPT_NO_VERSION = (1 << 2), + + // Alias -h for --help and -V for --version + KALOPT_ALIASES = (1 << 3), + + // Don't print any error message + // Implies KALOPT_NO_EXIT + KALOPT_NO_ERRORS = (1 << 4) | KALOPT_NO_EXIT, + + // Use KalGetProgName() instead of argv[0] + // as program name + KALOPT_USE_ARGV0 = (1 << 5), + + // Call argument parser for non-options + // Non-options arguments will be indicated by + // a key of 0, the argument passed as a parameter + KALOPT_PARSE_ALL = (1 << 6), + + // Call argument parser with options and non-options in the + // order they were found, instead of parsing options first + KALOPT_IN_ORDER = (1 << 7) | KALOPT_PARSE_ALL, + + // Stay silent all along + KALOPT_SILENT = KALOPT_NO_EXIT | KALOPT_NO_ERRORS + | KALOPT_NO_HELP | KALOPT_NO_VERSION, + +} CmdParserFlags_t; + +// +// Return values for the command parser +// These flags can be combined and are applied in order +// +// "Continue" and "Break" actions do not prevent +// later actions from applying +// +typedef enum { + + // Continue parsing new options + KALOPT_CONTINUE = 0, + + // Stop parsing further options + KALOPT_BREAK = (1 << 0), + + // Show help/version message (by default, continue parsing) + KALOPT_SHOWHELP = (1 << 1), + KALOPT_SHOWVERS = (1 << 2), + +} CmdParserReturn_t; + +//------------------------------------------// + +// +// An option for a command, e.g. "-o file" in "cc -o file" +// +typedef struct { + + // The option's name, e.g. "help" for "--help" + // May be 0, but only if letter is not zero + const char *longName; + + // The option's letter, e.g. 'h' for '-h' + int letter; + + // Address of the variable to put the parameter into + const char *param; + + // Option flags, see above + CmdOptionFlag_t flags; + + // The option's help text + // If this is 0, this option is hidden + const char *helpText; + + // The option's group, for sorting during --help + // Must be positive and < 256, or option won't shop up + // during help texts + int group; + +} CmdOption_t; + +// +// Program help/documentation strings; any can be 0 +// +// Help messages are printed in this format: +// (letting "this" be a CmdDocStrings_t* variable) +// +// Usage: (this->usage) +// (this->header) +// +// (this->groups[0]) +// -o, --option-name option description +// ... +// ... +// +// (this->bottom) +// +// XXX progname/version +// +typedef struct { + + const char *usage; + const char *header; + const char *bottom; + + // Groups documentation + // groups[n] should be either 0 or contain the + // description of the option group n + const char **groups; + +} CmdDocStrings_t; + +// +// The state variable passed to the parser containing useful infos +// +typedef struct { + + // Option we're currently parsing + const CmdOption_t *option; + + // Index (in argv) of the option we're parsing + int argvIndex; + + // Flags passed to KalParse(CmdLine|ArgV) + CmdParserFlags_t flags; + + // Has help/version messages been displayed already? + bool shownHelp; + bool shownVersion; + + // Standard output streams + FILE *outStream; + FILE *errStream; + + // Private, internal data; do not touch + void *priv; + +} CmdParserState_t; + +// +// The argument parser function +// +typedef CmdParserReturn_t (*CmdParser_t)(int key, + const char *param, + CmdParserState_t *state); + +//------------------------------------------// + +// +// Misc. simple functions +// +int KalComputeArgCount(const char **argv); +size_t KalComputeArgVecSize(const char **argv); + +// +// Command line to argument vector utility +// +error_t KalCmdLineToArgVecEx(const char *cmdLine, + int *argcPtr, + char **argv, + bool doEscaping); + +// +// KalCmdLineToArgVecEx but doEscaping = false +// +error_t KalCmdLineToArgVec(const char *cmdLine, + int *argcPtr, + char **argv); +/* + +// +// Argument vector to command line utility +// +error_t KalArgVecToCmdLineEx(char *cmdLine, + size_t lengthMax, + int argc, + const char **argv, + bool doUnEscaping); + +// +// KalArgVecToCmdLineEx but doUnEscapign = false +// +error_t KalArgVecToCmdLine(char *cmdLine, + size_t lengthMax, + int argc, + const char **argv); +// +// Command line parser; only takes an argument vector +// The argv argument *will* be modified and all parsed +// options and arguments will be removed, except argv[0] +// which is guanranteed to be left +// +error_t KalParseArgVecEx(int argc, + char **argv, + const CmdOption_t *options, + const CmdDocStrings_t *docStrings, + CmdParserFlags_t *flags, + CmdParser_t *parser, + FILE *outStream, + FILE *errStream); +// +// KalParseArgVecEx(argc, argv, options, docString, stdin, stdout, parser, NULL) +// +error_t KalParseArgVec(int argc, + char **argv, + const CmdOption_t *options, + const CmdDocStrings_t *docStrings, + CmdParserFlags_t *flags, + CmdParser_t *parser); + +*/ + +//------------------------------------------// + +#endif diff --git a/kaleid/include/common/kallist.h b/kaleid/include/extras/list.h similarity index 88% rename from kaleid/include/common/kallist.h rename to kaleid/include/extras/list.h index 8257b64..d394ddf 100644 --- a/kaleid/include/common/kallist.h +++ b/kaleid/include/extras/list.h @@ -7,32 +7,21 @@ // Desc: Doubly linked lists implementation // //----------------------------------------------------------------------------// -#ifndef _KALLIST_H -#define _KALLIST_H - #ifdef _KALEID_KERNEL -#error "kallist.h - Not ready for kernel compilation" +#error "extra/list.h - Not ready for kernel compilation" #endif -#ifndef _KALASSRT_H -#include +#ifndef _KALBASE_H +#include #endif -#ifndef _KALKERN_LOCKS_H -#include +#ifndef _KALEXTRAS_MALLOC_H +#include #endif -// -// XXX ¯\_(ツ)_/¯ -// -void *malloc(long); -void free(void *); +#ifndef _KALEXTRAS_LIST_H +#define _KALEXTRAS_LIST_H -#define AllocMemory malloc -#define FreeMemory free - -//------------------------------------------// -// Data structures // //------------------------------------------// typedef struct sListHead_t { @@ -49,8 +38,6 @@ typedef struct sListNode_t { struct sListNode_t *next; } ListNode_t; -//------------------------------------------// -// Functions // //------------------------------------------// // @@ -72,7 +59,7 @@ static inline ListHead_t } // -// Create a liste head +// Create a list head // static inline ListHead_t *CreateListHead(void) @@ -263,8 +250,6 @@ DestroyListHead(ListHead_t *head) // #define GetNodeData(node, type) ((type)(node)->data) -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/kernel/kernlocks.h b/kaleid/include/extras/locks.h similarity index 74% rename from kaleid/include/kernel/kernlocks.h rename to kaleid/include/extras/locks.h index 6d32224..e2333e3 100644 --- a/kaleid/include/kernel/kernlocks.h +++ b/kaleid/include/extras/locks.h @@ -7,66 +7,45 @@ // Desc: Spinlocks and mutexes // //----------------------------------------------------------------------------// -//------------------------------------------// -// Dependencies // -//------------------------------------------// +#ifndef _KALBASE_H +#include +#endif #ifdef _KALEID_KERNEL - #ifndef _KALKERN_BASE_H -#include "kernbase.h" +#include +#endif #endif -#else +#ifndef _KALEXTRAS_LOCKS_H +#define _KALEXTRAS_LOCKS_H -#ifndef _KALEID_H -#include -#endif - -#endif - -//------------------------------------------// -// Start of header // -//------------------------------------------// - -#ifndef _KALKERN_LOCKS_H -#define _KALKERN_LOCKS_H - -//------------------------------------------// -// Types // //------------------------------------------// typedef enum eLockType_t { - // + // Mutex-type lock // // WARNING // AquireLock() panics when used on a mutex while not running a process - // KLOCK_MUTEX, - // // Spinlock-type lock - // KLOCK_SPINLOCK, } LockType_t; -// // "volatile" may not be actually needed -// typedef struct sLock_t { unsigned int initDone; // initialized? - int locked; // is locked? LockType_t type; // lock type? + volatile int locked; // is locked? #ifdef _KALEID_KERNEL - Process_t *ownerProc; // unused - Process_t *waitingProc; // unused + Thread_t *ownerThread; // unused + Thread_t *waitingThread; // unused #endif -} volatile Lock_t; +} Lock_t; -//------------------------------------------// -// Functions // //------------------------------------------// // @@ -90,8 +69,8 @@ void InitLock(Lock_t *lock, LockType_t type) lock->locked = FALSE; lock->initDone = INITOK; #ifdef _KALEID_KERNEL - lock->ownerProc = NULL; - lock->waitingProc = NULL; + lock->ownerThread = NULL; + lock->waitingThread = NULL; #endif } @@ -132,9 +111,9 @@ void AquireLock(Lock_t *lock) #else if likely (lock->type == KLOCK_SPINLOCK) continue; #ifdef _OSK_SOURCE - else KalYieldCPU(); + else (void)KalYieldCPU(); #else - else sched_yield(); + else (void)sched_yield(); #endif #endif } @@ -149,7 +128,7 @@ static inline void ReleaseLock(Lock_t *lock) { #ifdef _KALEID_KERNEL - KalAssert(lock->ownerProc == GetCurProc()); + KalAssert(lock->ownerThread == GetCurThread()); #endif __sync_synchronize(); @@ -171,8 +150,6 @@ bool AttemptLock(Lock_t *lock) return retval; } -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/extras/malloc.h b/kaleid/include/extras/malloc.h new file mode 100644 index 0000000..65728cd --- /dev/null +++ b/kaleid/include/extras/malloc.h @@ -0,0 +1,33 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Memory allocation utilities // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_H +#include +#endif + +#ifndef _KALEXTRAS_MALLOC_H +#define _KALEXTRAS_MALLOC_H + +//------------------------------------------// + +// +// ¯\_(ツ)_/¯ +// +#ifndef _STDLIB_H +void *malloc(unsigned long); +void free(void *); +#endif + +#define AllocMemory malloc +#define FreeMemory free + +//------------------------------------------// + +#endif + diff --git a/kaleid/include/extras/prog.h b/kaleid/include/extras/prog.h new file mode 100644 index 0000000..57a008b --- /dev/null +++ b/kaleid/include/extras/prog.h @@ -0,0 +1,32 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Program utilities // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_H +#include +#endif + +#ifndef _KALEXTRAS_PROG_H +#define _KALEXTRAS_PROG_H + +//------------------------------------------// + +extern const char *__progname; +extern const char *__progvers; + +//------------------------------------------// + +const char *KalGetProgName(void); +const char *KalGetProgVersion(void); + +bool KalSetProgVers(const char *); +bool KalSetProgName(const char *); + +//------------------------------------------// + +#endif diff --git a/kaleid/include/kalbase.h b/kaleid/include/kalbase.h new file mode 100644 index 0000000..8743f05 --- /dev/null +++ b/kaleid/include/kalbase.h @@ -0,0 +1,59 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Kaleid API base minimal include file // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_H +#define _KALBASE_H + +//------------------------------------------// +// Building for OS/K // +//------------------------------------------// + +#ifndef _OSK_SOURCE +#if defined(_KALEID_KERNEL) || defined(_KALEID_SYSTEM) +#define _OSK_SOURCE 1 +#endif +#endif + +#if !defined(_OSK_SOURCE) && !defined(_KALEID_UNMASKED) +#ifndef _KALBASE_MASKS_H +#include +#endif +#endif + +//------------------------------------------// +// Include common part of API // +//------------------------------------------// + +#ifndef _KALBASE_BDEFS_H +#include +#endif + +#ifndef _KALBASE_ERRNO_H +#include +#endif + +#ifndef _KALBASE_TYPES_H +#include +#endif + +#ifndef _KALBASE_LIMITS_H +#include +#endif + +#ifndef _KALBASE_ASSERT_H +#include +#endif + +#ifndef _KALBASE_CRTLIB_H +#include +#endif + +//------------------------------------------// + +#endif diff --git a/kaleid/include/kaleid.h b/kaleid/include/kaleid.h index da81fce..36401a3 100644 --- a/kaleid/include/kaleid.h +++ b/kaleid/include/kaleid.h @@ -11,85 +11,23 @@ #define _KALEID_H //------------------------------------------// -// Building for OS/K // +// Include all Kaleid headers // //------------------------------------------// -#if !defined(_OSK_SOURCE) -# if defined(_KALEID_KERNEL) || defined(_KALEID_SYSTEM) -# define _OSK_SOURCE 1 -# endif +#ifndef _KALBASE_H +#include #endif -#if !defined(_OSK_SOURCE) -# ifndef _KALMASK_H -# include -# endif +#ifndef _KALEXT_H +#include #endif -//------------------------------------------// -// Building in C++ // -//------------------------------------------// - -#ifdef __cplusplus__ -extern "C" { -#endif - -//------------------------------------------// -// Include common part of API // -//------------------------------------------// - -#ifndef _KALDEFS_H -#include -#endif - -#ifndef _KALERROR_H -#include -#endif - -#ifndef _KALTYPES_H -#include -#endif - -#ifndef _KALLIMS_H -#include -#endif - -#ifndef _KALASSRT_H -#include -#endif - -#ifndef _KALCRT_H -#include -#endif - -//------------------------------------------// -// Include kernel headers // -//------------------------------------------// - #ifdef _KALEID_KERNEL - #ifndef _KALKERN_H #include #endif - -#else - -#ifndef _KALKERN_LOCKS_H -#include -#endif - #endif -//------------------------------------------// -// Building in C++ // -//------------------------------------------// - -#ifdef __cplusplus__ -} -#endif - -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/kalext.h b/kaleid/include/kalext.h new file mode 100644 index 0000000..a4c5b4f --- /dev/null +++ b/kaleid/include/kalext.h @@ -0,0 +1,44 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Kaleid extras main include file // +//----------------------------------------------------------------------------// + +#ifndef _KALBASE_H +#include +#endif + +//------------------------------------------// + +#ifndef _KALEXT_H +#define _KALEXT_H + +//------------------------------------------// +// Extra headers // +//------------------------------------------// + +#ifndef _KALEXTRAS_LOCKS_H +#include +#endif + +#ifndef _KALEXTRAS_PROG_H +#include +#endif + +#ifndef _KALEXTRAS_ARGV_H +#include +#endif + +#ifndef _KALEID_KERNEL +#ifndef _KALEXTRAS_LIST_H +#include +#endif +#endif + +//------------------------------------------// + +#endif + diff --git a/kaleid/include/kalkern.h b/kaleid/include/kalkern.h index df15c7d..2020436 100644 --- a/kaleid/include/kalkern.h +++ b/kaleid/include/kalkern.h @@ -7,16 +7,14 @@ // Desc: Kaleid Kernel main include file // //----------------------------------------------------------------------------// -//------------------------------------------// -// Dependencies // -//------------------------------------------// - -#ifndef _KALEID_H -#include +#ifndef _KALBASE_H +#include +#endif + +#ifndef _KALEXT_H +#include #endif -//------------------------------------------// -// Start of header // //------------------------------------------// #ifndef _KALKERN_H @@ -27,19 +25,20 @@ //------------------------------------------// #ifndef _KALKERN_BASE_H -#include +#include #endif -#ifndef _KALKERN_LOCKS_H -#include +#ifndef _KALKERN_TERMINAL_H +#include #endif -#ifndef _KALKERN_TERM_H -#include +// not ready for kernel compilation +#ifndef _KALEID_KERNEL +#ifndef _KALKERN_SCHED_H +#include +#endif #endif -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/kernel/kernbase.h b/kaleid/include/kernel/base.h similarity index 59% rename from kaleid/include/kernel/kernbase.h rename to kaleid/include/kernel/base.h index 54307c7..dbf03bd 100644 --- a/kaleid/include/kernel/kernbase.h +++ b/kaleid/include/kernel/base.h @@ -7,26 +7,18 @@ // Desc: Kaleid Kernel base types and functionalities // //----------------------------------------------------------------------------// -//------------------------------------------// -// Dependencies // -//------------------------------------------// - -#ifndef _KALEID_H -#include +#ifndef _KALBASE_H +#include #endif -//------------------------------------------// -// Start of header // //------------------------------------------// #ifndef _KALKERN_BASE_H #define _KALKERN_BASE_H -//------------------------------------------// -// Elementary types // //------------------------------------------// -typedef struct sLock_t volatile Lock_t; +typedef struct sLock_t Lock_t; typedef struct sThread_t Thread_t; typedef struct sProcess_t Process_t; typedef struct sTerminal_t Terminal_t; @@ -34,23 +26,23 @@ typedef struct sListHead_t ListHead_t; typedef struct sListNode_t ListNode_t; //------------------------------------------// -// Values for __kstate // -//------------------------------------------// + +/* XXX */ // // Current state of the kernel // typedef enum { - // the kernel is booting + // The kernel is booting KSTATE_INIT, - // the kernel is not running a process + // The kernel is not running a process KSTATE_KERNEL, - // a process is running in kernel mode + // A process is running in kernel mode KSTATE_PROCESS, - // the kernel is panicking + // The kernel is panicking KSTATE_PANIC, } KernelState_t; @@ -59,13 +51,12 @@ typedef enum { // Multiprocessor misc. // //------------------------------------------// - #ifndef INITOK #define INITOK ((unsigned int)0xCAFEBABE) #endif -#ifndef NCPU -#define NCPU 4 +#ifndef NCPUS +#define NCPUS 4 #endif #define GetCurCPU() 0 @@ -74,7 +65,7 @@ typedef enum { // Declare an (extern) CPU-local variable // #define __DECLARE_PER_CPU(_X, _Tp, _Qual) \ - _Qual _Tp __ ## _X [NCPU]; \ + _Qual _Tp __ ## _X [NCPUS]; \ static inline _Tp Get ## _X (void) \ { return __ ## _X [GetCurCPU()]; } \ static inline void _Set ## _X (_Tp _Y) \ @@ -90,51 +81,53 @@ typedef enum { // Actually creates a CPU-local variable // #define CREATE_PER_CPU(_X, _Tp) \ - _Tp __ ## _X [NCPU] = { (_Tp) 0 } + _Tp __ ## _X [NCPUS] = { (_Tp) 0 } -//------------------------------------------// -// Global constants // //------------------------------------------// // XXX -DECLARE_PER_CPU(PanicStr, const char *); +DECLARE_PER_CPU(PanicStr, const char *); -DECLARE_PER_CPU(KernState, KernelState_t); +DECLARE_PER_CPU(KernState, KernelState_t); -DECLARE_PER_CPU(_StdOut, Terminal_t *); -DECLARE_PER_CPU(_StdDbg, Terminal_t *); +DECLARE_PER_CPU(_StdOut, Terminal_t *); +DECLARE_PER_CPU(_StdDbg, Terminal_t *); -DECLARE_PER_CPU(CurProc, Process_t *); -DECLARE_PER_CPU(CurThread, Thread_t *); +DECLARE_PER_CPU(CurProc, Process_t *); +DECLARE_PER_CPU(CurThread, Thread_t *); + +DECLARE_PER_CPU(ReSchedFlag, bool); +DECLARE_PER_CPU(PreemptCount, ulong); -//------------------------------------------// -// Macros for manipulating said // -// global constants // //------------------------------------------// -#define SetKernState(x) \ - do { \ - _SetKernState(x); \ - } while (0) +#define SetKernState(x) _SetKernState(x); -#define GetStdOut() (GetCurProc() == NULL ? Get_StdOut() : NULL) -#define SetStdOut(tm) \ - do { \ - if (GetCurProc() == NULL) \ - _Set_StdOut(tm); \ - } while (0); - -#define GetStdDbg() (GetCurProc() == NULL ? Get_StdDbg() : NULL) -#define SetStdDbg(tm) \ - do { \ - if (GetCurProc() == NULL) \ - _Set_StdDbg(tm); \ - } while (0) +// +// StdOut/StdDbg manipulation +// +#define GetStdOut() (GetCurProc() == NULL ? Get_StdOut() : GetCurProc()->stdOut) +#define GetStdDbg() (GetCurProc() == NULL ? Get_StdDbg() : GetCurProc()->stdDbg) +#define SetStdOut(tm) do { if (GetCurProc() == NULL) _Set_StdOut(tm); \ + else GetCurProc()->stdOut = (tm); } while (0) +#define SetStdDbg(tm) do { if (GetCurProc() == NULL) _Set_StdDbg(tm); \ + else GetCurProc()->stdDbg = (tm); } while (0) +// +// Re-scheduling and preemption +// XXX XXX XXX atomic operations +// +#define SetReSchedFlag(x) _SetReSchedFlag(x) +#define DisablePreemption() _SetPreemptCount(GetPreemptCount()+1) +#define EnablePreemption() do { KalAssert(GetPreemptCount() > 0); \ + _SetPreemptCount(GetPreemptCount()-1); } while(0) //------------------------------------------// -// Other Macros // -//------------------------------------------// + +// +// Value of the preemption count indicating that preemption is activated +// +#define PREEMPT_ON 0 // // Size of a tabulation in spaces @@ -164,7 +157,44 @@ DECLARE_PER_CPU(CurThread, Thread_t *); #define HaltCPU() do { asm volatile ("hlt"); } while (1) //------------------------------------------// -// Some base functions // + +// +// A process +// +typedef struct sProcess_t { + + // Identifier + int pid; + + // Current priority class + int prioClass; + + // Default priority class (without boosts) + int defPrioClass; + + // Current priority level + int prioLevel; + + // Default priority level + int defPrioLevel; + + // Current state + int procState; + + // Remaining time running + ulong timeSlice; + + // Default time-slice + ulong defTimeSlice; + + // Scheduler internals + ListNode_t *schedNode; + + // Standard output/debug + Terminal_t *stdOut, *stdDbg; + +} Process_t; + //------------------------------------------// noreturn void StartPanic(const char *); @@ -174,10 +204,13 @@ noreturn void CrashSystem(void); // Useful I/O inlines // //------------------------------------------// + static inline void WriteByteOnPort(port_t port, port_t val) { - asm volatile ("out %0, %1" : : "dN" (port), "a" (val)); + KalAssert(FALSE && ENOSYS); + (void)port; + (void)val; } static inline @@ -196,9 +229,6 @@ ushort ReadWordFromPort(port_t port) return 0; } -//------------------------------------------// -// End of header // //------------------------------------------// #endif - diff --git a/kaleid/include/kernel/kernsched.h b/kaleid/include/kernel/sched.h similarity index 52% rename from kaleid/include/kernel/kernsched.h rename to kaleid/include/kernel/sched.h index d99f8de..5dc1023 100644 --- a/kaleid/include/kernel/kernsched.h +++ b/kaleid/include/kernel/sched.h @@ -7,49 +7,29 @@ // Desc: Scheduler header // //----------------------------------------------------------------------------// -//------------------------------------------// -// Dependencies // -//------------------------------------------// - #ifndef _KALKERN_BASE_H -#include "kernbase.h" +#include #endif -#ifndef _KALLIST_H -#include -#endif - -//------------------------------------------// -// Start of header // //------------------------------------------// #ifndef _KALKERN_SCHED_H #define _KALKERN_SCHED_H -//------------------------------------------// -// Preprocessor // //------------------------------------------// -// // Debug stuff -// #define printdbg printf -// // States for a process -// #define STATE_RUNNING 0 #define STATE_RUNNABLE 1 #define STATE_BLOCKED 2 -// // Time in ticks a process should be run -// #define DEF_PROC_TSLICE 5 // 20 ticks #define TCR_PROC_TSLICE 20000 // 20000 ticks (time critical) -//------------------------------------------// -// List heads // //------------------------------------------// DECLARE_PER_CPU(IdlePrioProcs, ListHead_t *); @@ -59,46 +39,6 @@ DECLARE_PER_CPU(TimeCritProcs, ListHead_t *); extern const char *PrioClassesNames[]; -//------------------------------------------// -// Data types // -//------------------------------------------// - -// -// A process -// -typedef struct sProcess_t { - - // Identifier - int pid; - - // Current priority class - int prioClass; - - // Default priority class (without boosts) - int defPrioClass; - - // Current priority level - int prioLevel; - - // Default priority level - int defPrioLevel; - - // Current state - int procState; - - // Remaining time running - ulong timeSlice; - - // Default time-slice - ulong defTimeSlice; - - // Scheduler internals - ListNode_t *schedNode; - -} Process_t; - -//------------------------------------------// -// Functions // //------------------------------------------// void SchedInit(void); @@ -107,8 +47,6 @@ void SchedFini(void); void SchedThisProc(Process_t *); void SchedOnTick(void); -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/include/kernel/kernterm.h b/kaleid/include/kernel/terminal.h similarity index 77% rename from kaleid/include/kernel/kernterm.h rename to kaleid/include/kernel/terminal.h index b5c32b6..0cb08f1 100644 --- a/kaleid/include/kernel/kernterm.h +++ b/kaleid/include/kernel/terminal.h @@ -7,23 +7,15 @@ // Desc: Terminal functions // //----------------------------------------------------------------------------// -//------------------------------------------// -// Dependencies // -//------------------------------------------// - #ifndef _KALKERN_BASE_H -#include "kernbase.h" +#include #endif -//------------------------------------------// -// Start of header // //------------------------------------------// -#ifndef _KALKERN_TERM_H -#define _KALKERN_TERM_H +#ifndef _KALKERN_TERMINAL_H +#define _KALKERN_TERMINAL_H -//------------------------------------------// -// Types // //------------------------------------------// // @@ -68,8 +60,6 @@ typedef struct sTerminal_t { } Terminal_t; -//------------------------------------------// -// Functions // //------------------------------------------// void InitTerms(void); @@ -78,8 +68,6 @@ error_t PutOnTerm(Terminal_t *, char); error_t PrintOnTerm(Terminal_t *, const char *); error_t ChTermColor(Terminal_t *, TermColor_t, TermColor_t); -//------------------------------------------// -// Macros // //------------------------------------------// #ifndef _NO_DEBUG @@ -88,8 +76,6 @@ error_t ChTermColor(Terminal_t *, TermColor_t, TermColor_t); # define DebugLog(...) #endif -//------------------------------------------// -// End of header // //------------------------------------------// #endif diff --git a/kaleid/kernel/init/table.c b/kaleid/kernel/init/table.c index 4b98d25..e610a42 100644 --- a/kaleid/kernel/init/table.c +++ b/kaleid/kernel/init/table.c @@ -19,3 +19,5 @@ CREATE_PER_CPU(_StdDbg, Terminal_t *); CREATE_PER_CPU(CurProc, Process_t *); CREATE_PER_CPU(CurThread, Thread_t *); +CREATE_PER_CPU(ReSchedFlag, bool); + diff --git a/kaleid/kernel/io/cursor.c b/kaleid/kernel/io/cursor.c new file mode 100644 index 0000000..e69de29 diff --git a/kaleid/kernel/io/term.c b/kaleid/kernel/io/term.c new file mode 100644 index 0000000..98d3827 --- /dev/null +++ b/kaleid/kernel/io/term.c @@ -0,0 +1,105 @@ +//----------------------------------------------------------------------------// +// GNU GPL OS/K // +// // +// Authors: spectral` // +// NeoX // +// // +// Desc: Early terminal functions // +//----------------------------------------------------------------------------// + +#include + +extern void VGA_Init(void); +extern Terminal_t VGA_Terminal; + +// +// Initialize standard output +// +void InitTerms(void) +{ + KalAssert(!GetStdOut() && !GetStdDbg()); + + VGA_Init(); + + // vgaTerm.initDone = INITOK; + + SetStdDbg(&VGA_Terminal); + SetStdOut(&VGA_Terminal); + + ClearTerm(GetStdOut()); +} + +// +// Fill terminal with spaces +// +error_t ClearTerm(Terminal_t *term) +{ + error_t retcode; + + if (term == NULL) return EINVAL; + KalAssert(term->initDone == INITOK); + + AquireLock(&term->lock); + retcode = term->ClearTermUnlocked(term); + ReleaseLock(&term->lock); + + return retcode; +} + +// +// Change the color code +// +error_t ChTermColor(Terminal_t *term, TermColor_t fgColor, TermColor_t bgColor) +{ + if (fgColor > KTERM_COLOR_WHITE || bgColor > KTERM_COLOR_WHITE) + return EINVAL; + + if (term == NULL) + return EINVAL; + + AquireLock(&term->lock); + + term->fgColor = fgColor; + term->bgColor = bgColor; + + ReleaseLock(&term->lock); + + return EOK; +} + +// +// Write a single character on the terminal +// +error_t PutOnTerm(Terminal_t *term, char ch) +{ + error_t retcode; + + if (term == NULL) return EINVAL; + KalAssert(term->initDone == INITOK); + + AquireLock(&term->lock); + retcode = term->PutOnTermUnlocked(term, ch); + ReleaseLock(&term->lock); + + return retcode; +} + +// +// Print string on terminal +// +error_t PrintOnTerm(Terminal_t *term, const char *str) +{ + error_t retcode = EOK; + + if (term == NULL) return EINVAL; + KalAssert(term->initDone == INITOK); + + AquireLock(&term->lock); + while (*str && retcode == EOK) { + retcode = term->PutOnTermUnlocked(term, *str++); + } + ReleaseLock(&term->lock); + + return retcode; +} + diff --git a/kaleid/kernel/ke/terminal.c b/kaleid/kernel/io/vga.c similarity index 66% rename from kaleid/kernel/ke/terminal.c rename to kaleid/kernel/io/vga.c index 1d7439b..f26ef65 100644 --- a/kaleid/kernel/ke/terminal.c +++ b/kaleid/kernel/io/vga.c @@ -4,102 +4,11 @@ // Authors: spectral` // // NeoX // // // -// Desc: Early terminal functions // +// Desc: VGA terminal functions // //----------------------------------------------------------------------------// #include -static Terminal_t vgaTerm; - -// -// Initialize standard output -// -void InitTerms(void) -{ - KalAssert(!GetStdOut() && vgaTerm.initDone != INITOK); - - vgaTerm.initDone = INITOK; - - SetStdDbg(&vgaTerm); - SetStdOut(&vgaTerm); - - ClearTerm(GetStdOut()); -} - -// -// Fill terminal with spaces -// -error_t ClearTerm(Terminal_t *term) -{ - error_t retcode; - - if (term == NULL) return EINVAL; - KalAssert(term->initDone == INITOK); - - AquireLock(&term->lock); - retcode = term->ClearTermUnlocked(term); - ReleaseLock(&term->lock); - - return retcode; -} - -// -// Change the color code -// -error_t ChTermColor(Terminal_t *term, TermColor_t fgColor, TermColor_t bgColor) -{ - if (fgColor > KTERM_COLOR_WHITE || bgColor > KTERM_COLOR_WHITE) - return EINVAL; - - if (term == NULL) - return EINVAL; - - AquireLock(&term->lock); - - term->fgColor = fgColor; - term->bgColor = bgColor; - - ReleaseLock(&term->lock); - - return EOK; -} - -// -// Write a single character on the terminal -// -error_t PutOnTerm(Terminal_t *term, char ch) -{ - error_t retcode; - - if (term == NULL) return EINVAL; - KalAssert(term->initDone == INITOK); - - AquireLock(&term->lock); - retcode = term->PutOnTermUnlocked(term, ch); - ReleaseLock(&term->lock); - - return retcode; -} - -// -// Print string on terminal -// -error_t PrintOnTerm(Terminal_t *term, const char *str) -{ - error_t retcode = EOK; - - if (term == NULL) return EINVAL; - KalAssert(term->initDone == INITOK); - - AquireLock(&term->lock); - while (*str && retcode == EOK) { - retcode = term->PutOnTermUnlocked(term, *str++); - } - ReleaseLock(&term->lock); - - return retcode; -} - //----------------------------------------------------------// // Internal functions for VGA terminals // // These DO NOT check input correctness // @@ -143,23 +52,17 @@ error_t VGA_PutOnTermUnlocked(Terminal_t *term, char ch) return EOK; } - // // Line feed first takes us to the very end of the line // Later in this function we actually do the line feed - // else if (ch == '\n') { term->currentY = term->width - 1; } - // // Tabulations account for "term->tabSize" spaces - // else if (ch == '\t') { prevY = term->currentY; for (i = 0; i < term->tabSize; i++) { - // // Make sure tabulations can't spread over two lines - // if (term->currentY == prevY) { VGA_PutOnTermUnlocked(term, ' '); } @@ -172,26 +75,18 @@ error_t VGA_PutOnTermUnlocked(Terminal_t *term, char ch) buffer[offset] = VGA_ComputeEntry(ch, VGA_ComputeColorCode(term->fgColor, term->bgColor)); } - // // Did we reach the end of line? - // if (++term->currentX == term->width) { term->currentX = 0; - // // Did we reach the buffer's end? - // if (++term->currentY == term->height) { - // // XXX scroll up - // term->currentY = 0; } } - // // Nothing can go wrong - // return EOK; } @@ -211,8 +106,9 @@ error_t VGA_PrintOnTermUnlocked(Terminal_t *term, const char *str) // // VGA output +// XXX custom sizes // -static Terminal_t vgaTerm = { +Terminal_t VGA_Terminal = { .initDone = FALSE, .lock = INITLOCK(KLOCK_MUTEX), @@ -234,3 +130,14 @@ static Terminal_t vgaTerm = { .PrintOnTermUnlocked = VGA_PrintOnTermUnlocked, }; + +// +// Initialize VGA output +// +void VGA_Init(void) +{ + KalAssert(VGA_Terminal.initDone != INITOK); + + VGA_Terminal.initDone = INITOK; +} + diff --git a/kaleid/kernel/ke/panic.c b/kaleid/kernel/ke/panic.c index 79c9a89..7b2bf6e 100644 --- a/kaleid/kernel/ke/panic.c +++ b/kaleid/kernel/ke/panic.c @@ -7,16 +7,15 @@ // Desc: How NOT to panic 101 // //----------------------------------------------------------------------------// -#define _UNLOCKED_IO #include // // Failed assert() handler // -noreturn void _assert_handler(const char *msg, - const char *file, - int line, - const char *func) +noreturn void __assert_handler(const char *msg, + const char *file, + int line, + const char *func) { DisableIRQs(); diff --git a/kaleid/kernel/proc/Makefile b/kaleid/kernel/proc/Makefile index 8001a5e..c83ea97 100644 --- a/kaleid/kernel/proc/Makefile +++ b/kaleid/kernel/proc/Makefile @@ -1,4 +1,6 @@ sched-test: - gcc -O2 -masm=intel -I../../include ./sched.c + gcc -O2 -Wall -Wextra -I../../include ./sched.c +clean: + rm a.out diff --git a/kaleid/kernel/proc/sched.c b/kaleid/kernel/proc/sched.c index ad040b1..46b75f6 100644 --- a/kaleid/kernel/proc/sched.c +++ b/kaleid/kernel/proc/sched.c @@ -7,27 +7,29 @@ // Desc: Scheduling algorithm // //----------------------------------------------------------------------------// -#include +#include #ifndef _KALEID_KERNEL #include + CREATE_PER_CPU(CurProc, Process_t *); // // For test purpose only // -int procslen = 9; +int procslen = 10; Process_t procs[] = { - { 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, 0, 0, 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 }, + { 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 }, }; #endif @@ -67,22 +69,22 @@ void SchedUnlock(void) { // The four priority classes of OS/2 // -CREATE_PER_CPU(IdlePrioProcs, ListHead_t *); -CREATE_PER_CPU(ReglPrioProcs, ListHead_t *); -CREATE_PER_CPU(ServPrioProcs, ListHead_t *); CREATE_PER_CPU(TimeCritProcs, ListHead_t *); +CREATE_PER_CPU(ServPrioProcs, ListHead_t *); +CREATE_PER_CPU(ReglPrioProcs, ListHead_t *); +CREATE_PER_CPU(IdlePrioProcs, ListHead_t *); const char *PrioClassesNames[] = { - "Idle priority class", - "Regular priority class", - "Server priority class", "Time-critical class", + "Server priority class", + "Regular priority class", + "Idle priority class", }; -enum { IDLE_PRIO_PROC = 0, - REGL_PRIO_PROC = 1, - SERV_PRIO_PROC = 2, - TIME_CRIT_PROC = 3, +enum { TIME_CRIT_PROC = 0, + SERV_PRIO_PROC = 1, + REGL_PRIO_PROC = 2, + IDLE_PRIO_PROC = 3, }; // @@ -111,8 +113,8 @@ Process_t *CompareProcs(Process_t *proc1, Process_t *proc2) { KalAssert(proc1 && proc2); - if (proc1->prioClass > proc2->prioClass) return proc1; - if (proc1->prioClass < proc2->prioClass) return proc2; + if (proc1->prioClass < proc2->prioClass) return proc1; + if (proc1->prioClass > proc2->prioClass) return proc2; if (proc1->prioLevel > proc2->prioLevel) return proc1; if (proc1->prioLevel < proc2->prioLevel) return proc2; @@ -126,7 +128,7 @@ Process_t *CompareProcs(Process_t *proc1, Process_t *proc2) static inline void SchedThisProcUnlocked(Process_t *proc) { - KalAssert(proc && proc->procState == STATE_RUNNABLE); + KalAssert(proc && proc->procState == STATE_RUNNABLE && !proc->schedNode); bool found = false; ListNode_t *iterNode = NULL; @@ -137,22 +139,20 @@ void SchedThisProcUnlocked(Process_t *proc) proc->schedNode = procNode; - //printdbg("Adding process %d to '%s'\n", proc->pid, PrioClassesNames[proc->prioClass]); - - // // Find a process with lesser priority - // for (iterNode = head->first; iterNode; iterNode = iterNode->next) { if (proc->prioLevel > GetNodeData(iterNode, Process_t *)->prioLevel) { + // Detect double insertions + KalAssert(proc->pid != GetNodeData(iterNode, Process_t *)->pid); + + // Add process to schedule AddNodeBefore(head, iterNode, procNode); found = true; break; } } - // // Didn't find any process with lesser priority - // if (found == false) { AppendNode(head, procNode); } @@ -198,9 +198,12 @@ void BlockCurProc(void) ListNode_t *procNode = GetCurProc()->schedNode; + KalAssert(procNode && "Blocking non-scheduled process"); + GetCurProc()->procState = STATE_BLOCKED; RemoveNode(procNode->head, procNode); + GetCurProc()->schedNode = NULL; SetCurProc(SelectSchedNext()); } @@ -208,6 +211,7 @@ static inline void ReSchedCurProc(void) { KalAssert(GetCurProc() && GetCurProc()->procState == STATE_RUNNING); + KalAssert(GetCurProc()->schedNode); // Restore default attributes, cancelling boosts GetCurProc()->prioClass = GetCurProc()->defPrioClass; @@ -233,15 +237,11 @@ void SchedOnTick(void) Process_t *procNext, *winner, *previous = GetCurProc(); - // // We're either idle or running something - // KalAssert(GetCurProc() == NULL || GetCurProc()->procState == STATE_RUNNING); - // // Have the current process spent its timeslice? // (To be handled in CPU decisions function) - // if (GetCurProc() != NULL) { if (GetCurProc()->timeSlice <= 1) { // Re-schedule @@ -251,42 +251,36 @@ void SchedOnTick(void) _SetCurProc(NULL); } - // // Otherwise, make it lose a tick - // else { GetCurProc()->timeSlice--; } } - // // Are we idle, or scheduling next process? - // if (GetCurProc() == NULL) { SetCurProc(SelectSchedNext()); goto leave; } - // - // Is there a higher priority process that is runnable? - // - procNext = SelectSchedNext(); - winner = CompareProcs(GetCurProc(), procNext); + // Is preemption on and a re-schedule is needed? + if (GetPreemptCount() == PREEMPT_ON && GetReSchedFlag()) { - // - // Yes, procNext should preempt current process - // - if (winner == procNext) { - // Re-schedule - ReSchedCurProc(); + // Is there a higher priority process that is runnable? + procNext = SelectSchedNext(); + winner = CompareProcs(GetCurProc(), procNext); - // Switch to procNext - SetCurProc(procNext); + // Yes, procNext should preempt current process + if (winner == procNext) { + // Re-schedule + ReSchedCurProc(); + + // Switch to procNext + SetCurProc(procNext); + } } - // // Current process won't be preempted and has time remaining - // leave: SchedUnlock(); @@ -301,7 +295,6 @@ leave: void InitSched(void) { int pid; - Process_t *proc; SchedLock(); @@ -345,7 +338,7 @@ void FiniSched(void) #ifndef _KALEID_KERNEL -#define PrintProc(proc) printdbg("{ %d, '%s', %d , %d}\n", (proc)->pid, \ +#define PrintProc(proc) printdbg("{ %d, '%s', %d , %lu}\n", (proc)->pid, \ PrioClassesNames[(proc)->prioClass], (proc)->prioLevel, (proc)->timeSlice); // @@ -358,7 +351,7 @@ void PrintList(ListHead_t *head) Process_t *proc; ListNode_t *node = head->first; - printdbg("len: %d\n", head->length); + printdbg("len: %lu\n", head->length); while (node) { proc = GetNodeData(node, Process_t *); @@ -402,8 +395,8 @@ int main(void) } if (tick == 50) { - procs[2].procState = STATE_RUNNABLE; - SchedThisProc(&procs[2]); + procs[0].procState = STATE_RUNNABLE; + SchedThisProc(&procs[0]); } printf("Tick %d - Running: ", tick); @@ -418,6 +411,9 @@ int main(void) SchedOnTick(); + if (tick == 50) // already done + puts("Re-scheduling process 0"); + tick++; } @@ -427,4 +423,3 @@ int main(void) } #endif -