I released my first OS project today (okay - it's second, because I've writing kernel as teenager). As teenager my kernel has only keyboard and screen (text) support and It's inspired on polish (from Poland) articles about how to write operating system. It have shell with commands like "piwo" (beer), allows to set screen attributes, scrolling, etc.
Currently I'm started from scratch and searching information in many places. I asked on this forum, of course
. My OS is one element currently (only a kernel and grub), but have:- GRUB modules support
- Some kind of objects support (modules and drivers can register object, interfaces by giving a name and version for each objects and function with giving information about return value and parameters ); In future: I will copy data from stack based on this information, when userspace program calls software interrupt.
- Kernel messages are only available, when you compile kernel with messages driver and order GRUB to load special language module - this module register translation object and after this message driver will outputs it's buffer to translation module - result returned by translation's module function will be directed to console module; I thought that I should put messages routines in userspace, so special message program will be started, but decided messages should be keep in kernel memory and writing messages driver and translation modules is a better approach - in future, when I implement buffer and dynamic memory support, translation modules will only poll, so the code would be better (who know why message driver should know anything about translation modules?)
- Very basic text console, interrupts, keyboard, etc. support. I write keyboard interrupt handler to test everything works and someone from this forum helped me
; text console even doesn't have scrolling support - when text overlaps, position of current character is set to 0 - no attributes support, etc.I will have small time to enjoying software programming now, because it's exams time, but I will continue to develop my kernel and operating system in free time. I know that OS develop is hard, but I decided to learn something new.
What my OS will look like in future:
- I decide to put as small API into my system as possible - programs could call function to obtaining object references and calling method on this object
- Calling method on object will create thread on owning process - I must find a way to prevent hanging another process
- Because there's an EFI, so I will create userspace program to help GRUB with select an OS - GRUB will load my OS, my OS loads and display OS selection menu, when user select another OS, we will start another system
- Webassembly support by module to write drivers, system services, etc.
- Because I will implement object-like kernel, filesystem could be queried as block device or filesystem, like: object_reference (sda1) -> interface (fs 1.0, block-device 2.0) -> function
- On panic, it will save logs into memory, reset into minimal-program to show logs
- When program is started, it will see only two objects - object manager (sets by parent), user (sets by kernel)
- I will implement screen program to support virtual terminals (it will worked thanks to object manager program's perspective - it proxy all object manager calls to real object manager, but separately handles query for tty module, returning own proxy object)
- Each user will own process, called user; programs could deliver very important messages to user program, etc.
- There's no uid - instead there will exist owner inode reference - user will be program, as I said, so default user will be symlink to default user program - only root could change that symlinks; and: when program A requires access to file owned by program B, we run user program from special entry point or special parameter (I must decide) and program B decided to grand access or not - I know, it will be slow.
There are link to my project page on sourceforge:
https://sourceforge.net/projects/kiss-em/
It's very little kernel