Developing a Multithreaded Kernel From Scratch!

What you'll learn

• How to create a kernel from scratch

• How to create a multi-tasking kernel

• How to handle malicious or problematic programs in your operating system. Terminating them if they misbehave.

• How memory works in computers

• The difference between kernel land, user land and the protection rings that make up modern computing

• Kernel design patterns used by the Linux kernel its self

• You will learn all about virtual memory and how to map virtual addresses to physical addresses

• You will learn how to make the kernel understand processes and tasks

• You will learn how to load ELF files

• You will learn how to debug disassembled machine code

• You will learn how to debug your kernel in an emulator with GDB.

• Introduction 04:13

  • 1: Introduction Preview 04:13

• Setup and a Brief Explanation of Kernel Development 12:46

  • 2: What Is Memory? Preview 03:11
  • 3: The Boot Process Explained Preview 07:05
  • 4: Installing What We Need For Real Mode Development 02:30

• Real Mode Development 1:15:22

  • 5: Hello World Bootloader 15:52
  • 6: Understanding Real Mode 04:49
  • 7: Segmentation Memory Model 08:35
  • 8: Improving Our Bootloader 07:30
  • 9: Preparing our bootloader to be booted on real hardware 05:34
  • 10: Writing our bootloader to a USB stick 02:42
  • 11: Booting The Bootloader Preview 00:42
  • 12: The Interrupt Vector Table Explained 03:58
  • 13: Implementing our own interrupts in real mode 06:46
  • 14: Disk Access And How It Works 05:44
  • 15: Reading from the hard disk 13:10

• Protected Mode Development 25:11:50

  • 16: What is Protected Mode? 06:34
  • 17: Switching To Protected Mode 15:43
  • 18: Restructuring Our Project 02:19
  • 19: Enabling the A20 line 02:37
  • 20: Creating a Cross Compiler So We Can Code In C 11:06
  • 21: Loading our 32 bit kernel into memory and working with debugging symbols 38:39
  • 22: Cleaning our object files 01:24
  • 23: Dealing With Alignment Issues 07:27
  • 24: C Code In Protected Mode 08:03
  • 25: Text Mode Explained 02:36
  • 26: Writing To The Screen, Hello World Tutorial 16:26
  • 27: Interrupt Descriptor Table Explained 08:33
  • 28: Implementing The Interrupt Descriptor Table 27:15
  • 29: Implementing In and Out Functions 09:46
  • 30: Programmable Interrupt Controller Explained 04:38
  • 31: Programmable Interrupt Controller Implementation 12:30
  • 32: Understanding The Heap And Memory Allocation 20:24
  • 33: Implementing Our Heap 1:04:42
  • 34: Creating the enable interrupts function 02:49
  • 35: Understanding Paging Preview 20:02
  • 36: Implementing Paging 28:15
  • 37: Modifying the page table 23:03
  • 38: Preparing To Read From The Hard Disk 02:45
  • 39: Reading from the disk in C with the ATA controller 10:34
  • 40: Improving Our Disk Driver 09:41
  • 41: What is a filesystem? 07:31
  • 42: Creating a path parser 36:40
  • 43: Creating a disk stream 15:44
  • 44: File Allocation Table Explained 18:00
  • 45: Starting To Create our FAT File system 13:59
  • 46: Understanding the VFS (Virtual File System) Layer 06:35
  • 47: Implementing our virtual filesystem core functionality 27:29
  • 48: Implementing FAT16 filesystem driver core functionality 17:12
  • 49: Implementing FAT16 Structures 19:18
  • 50: Implementing The FAT16 Resolver Function 33:31
  • 51: Implementing the VFS fopen function 24:09
  • 52: Implementing FAT16 fopen function 57:02
  • 53: Implementing the VFS fread function 06:06
  • 54: Implementing FAT16 fread functionality 08:32
  • 55: Implementing the VFS fseek functionality 02:54
  • 56: Implementing the FAT16 fseek functionality 05:41
  • 57: Implementing the fstat VFS functionality 04:30
  • 58: Implementing the FAT16 fstat function 06:12
  • 59: Implementing the VFS fclose functionality 02:34
  • 60: Implementing the FAT16 fclose functionality 07:09
  • 61: Implementing a kernel panic 02:14
  • 62: Understanding User Land 14:55
  • 63: Changing our kernel segment and data descriptors to be written in C 19:03
  • 64: Implementing The TSS (Task Switch Segment) 11:58
  • 65: Implementing Task Foundations 29:50
  • 66: Implementing Process Foundations Part 1 38:11
  • 67: Implementing Process Foundations Part 2 24:30
  • 68: Packing the GDT 01:09
  • 69: Implementing User Land Functionality 17:28
  • 70: Creating our first user process application 09:07
  • 71: Executing the process and dropping into user land privileges 07:56
  • 72: Changing the paging functionality 06:14
  • 73: Talking with the kernel from userland 20:15
  • 74: Creating the interrupt 0x80 for user process to kernel communication 24:11
  • 75: Creating the ability to create and execute kernel commands 11:17
  • 76: Creating our first kernel command 10:53
  • 77: Calling our kernel command 06:46
  • 78: Copying strings from the tasks process 14:37
  • 79: Reading the task's stack 21:09
  • 80: Creating the print command in the kernel 15:00
  • 81: Understanding keyboard access in protected mode 15:16
  • 82: Creating the virtual keyboard layer 15:45
  • 83: Creating the PS2 port keyboard driver part 1 23:23
  • 84: Improving our interrupt descriptor table design 20:01
  • 85: Creating a cleaner way to create interrupt handlers in the interrupt descriptor 10:19
  • 86: Changing The Current Process 07:28
  • 87: Creating the PS2 port keyboard driver part 2 13:35
  • 88: Getting a key from the keyboard buffer in user land 10:10
  • 89: Creating a putchar command that writes one character to the terminal 06:54
  • 90: Implementing backspace in the terminal 03:05
  • 91: Revising our stream reader 06:28
  • 92: Elf Files Explained 22:11
  • 93: Implementing The Elf Loader - Part 1 18:45
  • 94: Implementing The Elf Loader - Part 2 23:45
  • 95: Implementing The Elf Loader - Part 3 04:21
  • 96: Implementing The Elf Loader - Part 4 17:13
  • 97: Implementing The Elf Loader - Part 5 28:59
  • 98: Implementing The Elf Loader - Part 6 13:44
  • 99: Writing User Programs In C 14:49
  • 100: Implementing system print in stdlib 06:26
  • 101: Implementing system get key in stdlib 02:57
  • 102: Implementing Malloc In Our stdlib 21:44
  • 103: Implementing Free In Our stdlib 09:45
  • 104: Changing the way we map virtual pages for the process 02:12
  • 105: Implementing itoa function 04:46
  • 106: Implementing the putchar function 07:46
  • 107: Implementing the printf function 06:38
  • 108: Implementing the ability to read lines 10:12
  • 109: Creating a shell 09:03
  • 110: Loading other programs from our shell 26:44
  • 111: Creating some important stdlib functions 12:50
  • 112: Memory Mapping malloc in stdlib 08:44
  • 113: Memory Unmapping free In stdlib 11:06
  • 114: Process arguments - Part 1 09:34
  • 115: Process Arguments - Part 2 28:41
  • 116: Process Arguments - Part 3 05:38
  • 117: Implementing A 'System' Command 18:25
  • 118: Implementing program termination 15:19
  • 119: Handling program crashes 08:13
  • 120: Creating an exit command 05:46
  • 121: Handling caps lock, upper case and lower case letters 11:04
  • 122: Running multiple tasks at the same time multi-tasking 06:44

• Assembly Language Catchup 1:01:51

  • 123: What is assembly language? 01:48
  • 124: Installing the emulator 02:00
  • 125: Hello World In Assembly 17:45
  • 126: Transistors And Logic Gates Understanding The Processor 12:56
  • 127: Registers in the 8086 09:52
  • 128: Segmentation Memory Model Explained 08:52
  • 129: The Stack, Subroutines And Endiness Explained 08:38

• Conclusion 03:03

  • 130: Bonus Lecture 03:03

This course is designed to teach you how to create your very own multitasking operating system and kernel from scratch. It is assumed you have no experience in programming kernels and you are taught from the ground up.

Real Mode Development

Real mode is a legacy mode in all Intel processors that causes the processor to start in a legacy state, it performs like the old 8086 Intel processors did back in the way.

In the "Real Mode Development" section of the course we start by learning about the boot process and how memory works, we then move on to creating our very own boot loader that we test on our real machine! This boot loader will output a simple "Hello World!" message to the screen and we write this boot loader in purely assembly language.

In this section we also read a sector(512 bytes) from the hard disk and learn all about interrupts in real mode and how to create them.

This section gives you a nice taster into kernel development, without over whelming you with information. You are taught the basics and enough about the legacy processors to be able to move forward to more modern kernel development further into this course.

Protected Mode Development

In this section we create a 32 bit multi-tasking kernel that has the FAT16 filesystem. Our kernel will use Intel's built in memory protection and security mechanisms that allow us to instruct the processor to protect our kernel and prevent user programs from damaging it.

This section is very in depth, you are taught all about paging and virtual memory. We take advantage of clever instructions in Intel processors to allow all processes to share the same memory addresses, this is known as memory virtualization. We map memory addresses to point to different physical memory addresses to create the illusion that every process that is running is loaded at the same address. This is a very common technique in kernel development and is also how swap files work (Those files that are used to compensate for when you run out of usable RAM).

We create our own virtual filesystem layer that uses a design that is similar to the Linux kernel. This clever abstraction that will be taught to you was inspired by the instructors knowledge of writing Linux kernel drivers in his past.

You are taught about the design of the FAT16 filesystem and how the FAT16 filesystem is broken down into clusters and that they can chain together. We then implement our very own FAT16 filesystem driver allowing files to be born!

We implement functionality for tasks and processes and write our own keyboard drivers.

In this course you also get to learn how memory management works, we implement the "malloc" and "free" functions creating our very own heap that's designed to keep track of what memory is being used. Memory management is essential in any operating system and kernel.

Let us not forget that we even create an ELF file loader, we will compile all our operating systems programs into ELF files and allow the loading of binary programs or ELF programs. ELF files contain a lot of information that describes our program for example where our program should be loaded into memory and the different sections of the program.

By the end of this course you will have a fully functioning 32 bit multi-tasking kernel that can have many processes and tasks running at the same time. You will have a working shell that we can use as well.

Assembly language bonus

This is a bonus section designed to bring your assembly skills up to scratch should you struggle a little bit with the assembly language in this course. It's however advised you come to this course with experience in assembly language, we do use it and its important. Never the less if you want to take a chance on this course with no assembly experience then this section will help point you in the right direction so your able to take what you learned and apply it to the kernel.

Taught by an expert that that has created Linux kernel modules professionally in the work place.

• Beginner kernel developers who want to learn how to create kernels

• You must know the C programming language

• It is wise have some basic knowledge in assembly language

• You should have a Linux operating system, free to install from the internet (We use Ubuntu in this course)

Currently there are no Q&As for this course. Be the first to ask a question.

Reed courses certificate of completion

Digital certificate - Included