DEV Community

Ravi Bhuvan
Ravi Bhuvan

Posted on

Building a chikku OS

#c #computerscience #sideprojects #tutorial

mintOS Developer Handbook

Table of Contents

  1. Boot Process
  2. Screen Driver
  3. Keyboard Driver
  4. Input System
  5. Kernel Library
  6. Parser & Shell

Tool Purpose

GCC Compiles C code
NASM Assembler
QEMU Emulator for testing OS
GRUB Bootloader
xorriso Creates bootable ISO

kernal.c 

void kernel_main() {
    char* video = (char*) 0xB8000;

    const char* text = "Hello from mintOS";

    for (int i = 0; text[i] != '\0'; i++) {
        video[i * 2] = text[i];
        video[i * 2 + 1] = 0x07;
    }

    while (1);
}
Enter fullscreen mode Exit fullscreen mode

This C program displays text on the screen using VGA text mode.

VGA Video Memory

0xB8000 is a special memory address: the VGA text-mode video
memory in older PCs.\
VGA uses a reserved area of RAM that the display hardware reads to
show text and graphics.

In VGA text mode, each character cell uses two bytes:

video[i * 2];
video[i * 2 + 1];
Enter fullscreen mode Exit fullscreen mode

Here: - video[0] = 'H' places the character 'H' in the first
screen position. - video[1] sets the color attribute for that
character.

Example:

1 byte = character
1 byte = color info
video[0] = 'H';   // character
video[1] = 0x07;  // color
Enter fullscreen mode Exit fullscreen mode

Configuration Files and GRUB

Create a .cfg file\
A .cfg file is a configuration file that contains settings or
instructions for a program.

GRUB (Grand Unified Bootloader) is a bootloader that: - Shows a boot
menu - Loads the kernel - Starts the operating system

In short, GRUB helps boot the OS.

GRUB = helper that knows where everything is stored

Without GRUB, you would manually tell the computer: - "Go to this disk
location." - "Read these sectors." - "Load this data into memory."

So GRUB saves you from doing that low-level work manually.

  • .cfg → instructions/settings a program reads\
  • .sh → shell script with commands the computer executes (starts programs, runs commands in the terminal)

Program start sequence:

Program starts
   ↓
Reads .cfg file
   ↓
Uses those settings/instructions
Enter fullscreen mode Exit fullscreen mode

Boot Process: BIOS/UEFI → GRUB → OS

BIOS/UEFI is firmware built into the motherboard. Every time you
turn on a computer:

  1. BIOS/UEFI firmware runs automatically.
  2. It starts the bootloader.
  3. The bootloader starts the operating system.

Basic boot flow:

Power On
→ BIOS/UEFI
→ GRUB starts
→ GRUB reads grub.cfg
→ GRUB loads the OS
→ OS starts
Enter fullscreen mode Exit fullscreen mode

boot.asm -- Multiboot Entry Point

Create boot.asm:

section .multiboot
    align 4
    dd 0x1BADB002
    dd 0x00
    dd -(0x1BADB002 + 0x00)

section .text
    global _start
    extern kernel_main

_start:
    call kernel_main

hang:
    jmp hang
Enter fullscreen mode Exit fullscreen mode

boot.asm is the initial startup code that helps GRUB start
your kernel.\
It: - Tells GRUB this is a valid multiboot kernel - Calls
kernel_main() (from kernal.c) after the kernel is loaded into
RAM

dd 0x1BADB002 is a special magic number used by GNU GRUB.\
A magic number is a fixed value used to identify a file format or
type.

Boot code: → runs directly on hardware before any OS exists\
Normal software: → runs on top of the operating system

The magic number does not specify where to load the kernel. It
only identifies the file type to the bootloader.

Full Boot Flow So Far 

Power On
→ BIOS/UEFI starts
→ GRUB starts
→ GRUB reads grub.cfg
→ GRUB loads kernel (using boot.asm + kernel.bin) into RAM
→ boot.asm starts
→ kernel_main() runs
→ Your OS runs
Enter fullscreen mode Exit fullscreen mode

Tools and Concepts

  • GNU Compiler Collection (GCC)\
    Converts C/C++ code into machine code the computer can run.

  • Linker script\
    Defines how the final kernel binary is laid out in memory.

  • QEMU\
    An emulator/virtual machine that creates a virtual computer
    inside your real computer so you can run operating systems
    safely    .\
    QEMU provides a virtual machine where this minimal OS runs.

Now you have created a basic mini OS that prints a static message.

├── Makefile
├── MintOS.iso
├── boot
│   └── boot.asm
├── boot.o
├── iso
│   └── boot
│       ├── grub
│       │   └── grub.cfg
│       └── kernel.bin
├── kernel
│   ├── kernel.c
│   ├── screen.c
│   └── screen.h
├── kernel.bin
├── kernel.o
├── linker.ld
└── screen.o
Enter fullscreen mode Exit fullscreen mode

Makefile → instructions for building the OS automatically boot/boot.asm
→ startup assembly code for the kernel iso/ → folder used to create the
bootable ISO iso/boot/grub/grub.cfg → GNU GRUB boot configuration file
kernel/kernel.c → main kernel C code kernel/screen.c → screen display
functions kernel/screen.h → declarations for screen functions linker.ld
→ tells how to arrange the kernel in RAM

Makefile -----------------------------
all:
        nasm -f elf32 boot/boot.asm -o boot.o
        gcc -m32 -ffreestanding -c kernel/kernel.c -o kernel.o
        gcc -m32 -ffreestanding -c kernel/screen.c -o screen.o

        ld -m elf_i386 -T linker.ld -o kernel.bin boot.o kernel.o screen.o

        cp kernel.bin iso/boot/kernel.bin

        grub-mkrescue -o mintOS.iso iso

        qemu-system-x86_64 -cdrom mintOS.iso

## boot.asm ----------------------------------

section .multiboot
    align 4
    dd 0x1BADB002
    dd 0x00
    dd -(0x1BADB002 + 0x00)

section .text
    global _start
    extern kernel_main

_start:
    call kernel_main

hang:
    jmp hang

grub.cfg -----------------------------------

menuentry "mintOS" {
    multiboot /boot/kernel.bin
    boot
}

kernel.c -------------------------------------------

#include "screen.h"

void kernel_main() {

    clear_screen();

    print("Welcome to MintOS!");

    while (1);

screen.c -------------------------------------------------

#include "screen.h"

char* video = (char*) 0xB8000;
int cursor = 0;

void clear_screen() {
    for (int i = 0; i < 80 * 25; i++) {
        video[i * 2] = ' ';
        video[i * 2 + 1] = 0x07;
    }

    cursor = 0;
}

void print(const char* str) {
    int i = 0;

    while (str[i] != '\0') {
        video[cursor++] = str[i++];
        video[cursor++] = 0x07;
    }


screen.h --------------------------------------------------

#ifndef SCREEN_H
#define SCREEN_H

void print(const char* str);
void clear_screen();

#endif

linker.ld ------------------------------------------

ENTRY(_start)

SECTIONS
{
    . = 1M;

    .text :
    {
        *(.multiboot)
        *(.text)
    }

    .rodata :
    {
        *(.rodata)
    }

    .data :
    {
        *(.data)
    }

    .bss :
    {
        *(.bss)
    }
}
Enter fullscreen mode Exit fullscreen mode

Phase 3 --- Keyboard Driver

Until now, mintOS could only display text. It could not receive
any input from the user.

The goal of this phase is to make the keyboard interactive.

How the Keyboard Works

A keyboard does not send characters like 'A' or 'B'.

Instead, it sends scan codes.

Key Scan Code

A 0x1E
B 0x30
C 0x2E
Enter 0x1C
Space 0x39
Backspace 0x0E

Example:

Press A
   ↓
Keyboard sends
0x1E
Enter fullscreen mode Exit fullscreen mode

The operating system converts the scan code into an ASCII character.

0x1E
   ↓
'a'
Enter fullscreen mode Exit fullscreen mode

Memory-Mapped vs Port-Mapped I/O

Previously, we wrote directly to VGA memory.

0xB8000
Enter fullscreen mode Exit fullscreen mode

This is called Memory-Mapped I/O.

The keyboard is different.

It communicates through I/O Ports.

CPU
 │
 ├── Memory
 │      0xB8000
 │
 └── I/O Ports
        0x60
Enter fullscreen mode Exit fullscreen mode
  • Memory-mapped I/O → Access hardware through memory addresses.
  • Port-mapped I/O → Access hardware through I/O ports.

The keyboard uses:

Port 0x60
Enter fullscreen mode Exit fullscreen mode

Reading an I/O Port

The CPU provides a special instruction:

in
Enter fullscreen mode Exit fullscreen mode

Since C cannot execute CPU instructions directly, we use inline
assembly.

The helper function:

inb(0x60)
Enter fullscreen mode Exit fullscreen mode

reads one byte from keyboard port 0x60.

New Files Added 

kernel/
    keyboard.c
    keyboard.h
    ports.h
Enter fullscreen mode Exit fullscreen mode

Every hardware component gets its own driver.

Examples:

keyboard.c
timer.c
mouse.c
disk.c
Enter fullscreen mode Exit fullscreen mode

Scancode Lookup Table

The keyboard driver contains a lookup table.

static const char scancode_table[128];
Enter fullscreen mode Exit fullscreen mode

This converts scan codes into ASCII characters.

Example:

Scan Code Character

0x02 '1'
0x03 '2'
0x1E 'a'
0x30 'b'

The array index is the scan code.

Example:

scancode_table[0x1E]
Enter fullscreen mode Exit fullscreen mode

returns

'a'
Enter fullscreen mode Exit fullscreen mode

Keyboard Flow 

Press Key
     ↓
Keyboard
     ↓
Port 0x60
     ↓
inb(0x60)
     ↓
Scan Code
     ↓
Lookup Table
     ↓
ASCII Character
     ↓
kernel.c
     ↓
Print on Screen
Enter fullscreen mode Exit fullscreen mode

Continuous Polling

The kernel continuously checks for keyboard input.

while (1)
     ↓
keyboard_get_char()
     ↓
Print Character
Enter fullscreen mode Exit fullscreen mode

This method is called Polling.

The kernel repeatedly asks:

Any key?

Any key?

Any key?
Enter fullscreen mode Exit fullscreen mode

Key Press vs Key Release

Every key usually generates two scan codes.

Example:

Press A
↓
0x1E

Release A
↓
0x9E
Enter fullscreen mode Exit fullscreen mode

Notice:

0x9E = 0x1E + 0x80
Enter fullscreen mode Exit fullscreen mode

To detect a key release:

if (scancode & 0x80)
Enter fullscreen mode Exit fullscreen mode

Meaning:

  • Result = 0 → Key Press
  • Result ≠ 0 → Key Release

This works because the highest bit (MSB) is set only for release
scan codes.

Current Limitation

Currently, the kernel continuously reads from port 0x60.

It does not first check whether the keyboard has produced a new
scan code.

Therefore, pressing a key once may repeatedly print the same character.

Example:

Press F

ffffffffffffffff...
Enter fullscreen mode Exit fullscreen mode

The next improvement is to check the keyboard status port (0x64)
before reading from 0x60.

Summary

  • Keyboard sends scan codes, not characters.
  • Scan codes are read from I/O port 0x60.
  • inb() reads data from an I/O port.
  • A lookup table converts scan codes → ASCII.
  • The kernel continuously polls the keyboard.
  • Each key generates Press (Make Code) and Release (Break Code) scan codes.
  • The next step is to check port 0x64 to avoid reading the same scan code repeatedly.

Phase 4 --- Input System

Until now, the keyboard could only display characters on the screen.

The next step was to store everything the user types inside an input
buffer so the shell can execute complete commands.

Input Flow 

Keyboard
    ↓
keyboard_get_char()
    ↓
Input Buffer
    ↓
Press Enter
    ↓
shell_execute()
Enter fullscreen mode Exit fullscreen mode

Input Buffer

The input buffer stores every character typed by the user.

Example:

help

↓

h e l p \0
Enter fullscreen mode Exit fullscreen mode

Functions added:

input_add_char()
input_backspace()
input_submit()
input_clear()
input_get_buffer()
Enter fullscreen mode Exit fullscreen mode

Enter Key

When Enter is pressed:

Input Buffer
      ↓
input_submit()
      ↓
shell_execute()
Enter fullscreen mode Exit fullscreen mode

Backspace

Backspace removes the last character from the input buffer.

Phase 5 --- Kernel Library

The kernel now has its own standard library.

Current structure:

kernel/
├── include/
│   ├── string.h
│   └── memory.h
└── lib/
    ├── string.c
    └── memory.c
Enter fullscreen mode Exit fullscreen mode

Functions implemented:

strlen()
strcmp()
strcpy()
strncpy()
strchr()

memcpy()
memset()
memcmp()
Enter fullscreen mode Exit fullscreen mode

These functions will be reused by every subsystem in mintOS.

Phase 6 --- Parser & Shell

Until now, the shell compared the entire input string.

Example:

echo Hello World
Enter fullscreen mode Exit fullscreen mode

This would never equal:

echo
Enter fullscreen mode Exit fullscreen mode

So we introduced a parser.

Goal

Transform:

echo Hello World
Enter fullscreen mode Exit fullscreen mode

into:

Command:
echo

Argument:
Hello World
Enter fullscreen mode Exit fullscreen mode

Parser Flow 

Input Buffer
      │
      ▼
Tokenizer
      │
      ▼
Parser
      │
      ▼
Commands
Enter fullscreen mode Exit fullscreen mode

strchr()

The parser uses:

char *strchr(const char *str, char ch);
Enter fullscreen mode Exit fullscreen mode

to find the first space.

Example:

echo Hello World
    ^
Enter fullscreen mode Exit fullscreen mode

The space is replaced with:

'\0'
Enter fullscreen mode Exit fullscreen mode

Memory changes from:

e c h o _ H e l l o \0
Enter fullscreen mode Exit fullscreen mode

to:

e c h o \0 H e l l o \0
Enter fullscreen mode Exit fullscreen mode

Now we have two strings:

command  -> "echo"
argument -> "Hello World"
Enter fullscreen mode Exit fullscreen mode

ParsedCommand

The parser returns:

typedef struct
{
    char *command;
    char *argument;
} ParsedCommand;
Enter fullscreen mode Exit fullscreen mode

Example:

ParsedCommand parsed = parse_command(input);
Enter fullscreen mode Exit fullscreen mode

Shell Layout 

shell/
├── shell.c
├── parser.c
├── parser.h
├── commands.c
└── commands.h
Enter fullscreen mode Exit fullscreen mode

Responsibilities:

  • parser.c → Split the input.
  • shell.c → Execute commands.
  • commands.c → Implement each command.

Echo Command 

> echo Hello World

Hello World
Enter fullscreen mode Exit fullscreen mode

Implementation:

void cmd_echo(const char *text)
{
    print(text);
    print("\n");
}
Enter fullscreen mode Exit fullscreen mode

Current mintOS Structure 

kernel/
├── arch/
├── drivers/
├── include/
├── input/
├── lib/
└── shell/
Enter fullscreen mode Exit fullscreen mode

Next Roadmap

  • Improve parser
  • Command table
  • GDT
  • IDT
  • Interrupts
  • Memory Manager
  • PIT Timer

Top comments (0)