C_SOURCES = $(wildcard kernel/*.c drivers/*.c cpu/*.c libc/*.c)

HEADERS = $(wildcard kernel/*.h drivers/*.h cpu/*.h libc/*.h)

OBJ = ${C_SOURCES:.c=.o cpu/interrupt.o}

CC = /usr/local/i386elfgcc/bin/i386-elf-gcc

GDB = /usr/local/i386elfgcc/bin/i386-elf-gdb

CFLAGS = -g

os-image.bin: boot/bootsect.bin kernel.bin

cat $^ > os-image.bin

kernel.bin: boot/kernel_entry.o ${OBJ}

i386-elf-ld -o $@ -Ttext 0x1000 $^ --oformat binary

kernel.elf: boot/kernel_entry.o ${OBJ}

i386-elf-ld -o $@ -Ttext 0x1000 $^

run: os-image.bin

qemu-system-i386 -fda os-image.bin

debug: os-image.bin kernel.elf

qemu-system-i386 -s -fda os-image.bin -d guest_errors,int &

${GDB} -ex "target remote localhost:1234" -ex "symbol-file kernel.elf"

%.o: %.c ${HEADERS}

${CC} ${CFLAGS} -ffreestanding -c $< -o $@

%.o: %.asm

nasm $< -f elf -o $@

%.bin: %.asm

nasm $< -f bin -o $@

clean:

rm -rf *.bin *.dis *.o os-image.bin *.elf

rm -rf kernel/*.o boot/*.bin drivers/*.o boot/*.o cpu/*.o

#include "../drivers/ports.h"

../20-interrupts-timer/Makefile

**Goal: Clean the code a bit and parse user input**

In this lesson we will do tho things. First, we will clean up the code a bit, so it is ready

for further lessons. During the previous ones I tried to put things in the most predictable places,

but it is also a good exercise to know when the code base is growing and adapt it to current

and further needs.

Code cleaning

First of all, we will quickly start to need more utility functions

for handling strings and so on. In a regular OS, this is called the C library,

or libc for short.

Right now we have a `utils.c` which we will split into `mem.c` and `string.c`, with their respective headers.

Second, we will create a new function `irq_install()` so that the kernel

only needs to perform one call to initialize all the IRQs. That function

is akin to `isr_install()` and placed on the same `irq.c`.

While we're here, we will disable the `kprint()` on `timer_callback()`

to avoid filling the screen with junk, now that we know that it works

properly.

There is not a clear distinction between `cpu/` and `drivers/`.

Keep in mind that I'm

creating this tutorial while following many others, and each of them

has a distinct folder structure. The only change we will do for now is to

move `drivers/ports.*` into `cpu/` since it is clearly cpu-dependent code.

`boot/` is also CPU-dependent code, but we will not mess with it until

we implement the boot sequence for a different machine.

Keyboard characters

How to access the typed characters, then?

- When a key is pressed, the callback gets the ASCII code via a new

arrays which are defined at the beginning of `keyboard.c`

- The callback then appends that character to a buffer, `key_buffer`

- It is also printed on the screen

- When the OS wants to read user input, it calls `libc/io.c:readline()`

`keyboard.c` also parses backspace, by removing the last element

of the key buffer, and deleting it from the screen, by calling

`screen.c:kprint_backspace()`. For this we needed to modify a bit

`print_char()` to not advance the offset when printing a backspace

Responding to user input

The keyboard callback checks for a newline, and then calls the kernel,

telling it that the user has input something. Out final libc function

is `strcmp()`, which compares two strings and returns 0 if they

are equal. If the user inputs "END", we halt the CPU.

This is the most basic shell ever, but you should be proud, because

we implemented it from scratch. Do you realize how cool this is?

If you want to, expand `kernel.c` to parse more stuff. In the future,

when we have a filesystem, we will allow the user to run some basic commands.

../20-interrupts-timer/boot

#include "idt.h"

void set_idt_gate(int n, u32 handler) {

idt[n].low_offset = low_16(handler);

idt[n].sel = KERNEL_CS;

idt[n].always0 = 0;

idt[n].flags = 0x8E;

idt[n].high_offset = high_16(handler);

}

void set_idt() {

idt_reg.base = (u32) &idt;

idt_reg.limit = IDT_ENTRIES * sizeof(idt_gate_t) - 1;

/* Don't make the mistake of loading &idt -- always load &idt_reg */

__asm__ __volatile__("lidtl (%0)" : : "r" (&idt_reg));

}

#ifndef IDT_H

#define IDT_H

#include "types.h"

#define KERNEL_CS 0x08

typedef struct {

u16 low_offset; /* Lower 16 bits of handler function address */

u16 sel; /* Kernel segment selector */

u8 always0;

/* First byte

u8 flags;

u16 high_offset; /* Higher 16 bits of handler function address */

} __attribute__((packed)) idt_gate_t ;

typedef struct {

u16 limit;

u32 base;

} __attribute__((packed)) idt_register_t;

#define IDT_ENTRIES 256

idt_gate_t idt[IDT_ENTRIES];

idt_register_t idt_reg;

void set_idt_gate(int n, u32 handler);

void set_idt();