A long wait.....!!!!!

Final Year.... lot of work to do.

So next post in MAY!!! 

Sorry for the delay.

If you want some help then visit OSDEV.

How can we detect the memory?(DAY 11)

Lets watch the following video before we go ahead with memory management. The video clip is from a famous TV series "NEWSROOM".

If you saw that video then the person sitting in the center quotes "first step in solving any problem is in recognizing that there is one". This part of the tutorial is inspired by that quote. 

"first step in managing memory is in recognizing that there is one"

To accomplish this grub comes to our rescue. So how exactly the grub loader help us in this.

Once the operating system is loaded by the grub and its execution starts, the EBX register contains the physical address of a Multiboot information data structure. Through this information the boot loader communicates important information to the operating system. The Multiboot information is placed anywhere in memory by the boot loader (with the exception of the memory reserved for the kernel and boot modules, of course). The operating system uses this information to detect the memory.

Steps that should be followed :-

1) Create a file with name multiboot.h.

2) Copy the code on this page and paste it in multiboot.h.

3) Save it in the same folder where your kernel.c lies.

4) Edit the kernel.c

//add this 
#include "multiboot.h"
//change the kernel_main function
void kernel_main(multiboot_info_t* mbd,unsigned int magic)
{
//Now we have the memory information with us.

//Use your printf function to print the data here.

}

5) To understand each part of multiboot.h you should go through this. Basically the "multiboot.h" has the structure of how the memory map is stored in memory. You get a pointer to that memory section through "mbd" variable. If you understand pointers in C then it won't be difficult to get the memory map.
6) Print each value. Then you will find that the values are consistent with the memory you allocated for this virtual machine (Note: you have to patiently check the values as they involve a lot of calculations). You should also go through this to understand what part of memory is usable.

Memory Management (Day 10)

I expect that you have written your own printf function which is way better than printf I wrote in my previous post. Also write a scanf function if you get time. Writing a scanf function is not going to be tough. First step would be to find the interrupt which is there for keyboard. Then use this interrupt to get keyboard input. Once you have the keyboard input, use the your printf function to print the data on screen.

Have a look at standard C implementation of printf and scanf for writing a good printf and scanf function of your own.

Today we will move on to next important topic of operating system development which is memory management. I have shared a link to a book which I found very interesting. I hope you should read it too. It's the first (1) link. It is about memory management.

Following are the few questions that you need to answer so that you can write your own memory manager.

Why is memory management required? 

Wikipedia

Following question will be explained in detail in my next few posts...

How can we detect the memory?

Here GRUB will come to our rescue.

What part of the memory is usable?

Not all the memory you have is usable. We need to find out the part which is usable.

How should we manage memory?

In this I will explain paging and segmentation which are very important concepts in operating system management.

"Hello World" Program!!! (Day 9)

Today we are going to see our operating system print "Hello world" on the screen.

Software that you need to install are xorris and grub

sudo apt-get install xorris
sudo apt-get install grub

Create a file grub.cfg and paste the code given below. Instead of myos you can give any name that suits you.

menuentry "myos" {
 multiboot /boot/myos.bin
}

Following is a shell script file which will compile the OS code and generate bootable image. We are using this file because there are many steps involved in compilation and you may not want to go through each step every time you make changes to the code.

#!/bin/sh
export PREFIX="$HOME/opt/cross"
export TARGET=i586-elf
export PATH="$PREFIX/bin:$PATH"
i586-elf-gcc -c kernel.c -o kernel.o -std=gnu99 -ffreestanding -O2 -Wall -Wextra
i586-elf-as boot.s -o boot.o
i586-elf-gcc -T linker.ld -o myos.bin -ffreestanding -O2 -nostdlib boot.o kernel.o -lgcc
mkdir -p isodir#comment this line when you use this file again to compile your code.
mkdir -p isodir/boot#comment this line when you use this file again to compile your code.
cp myos.bin isodir/boot/myos.bin
mkdir -p isodir/boot/grub#comment this line when you use this file again to compile your code.
cp grub.cfg isodir/boot/grub/grub.cfg
grub-mkrescue -o myos.iso isodir

Save the above commands in a file with name "build" in the same folder where your rest of the code resides.
Now execute the following code in the terminal.

chmod +x build
./build

Now your bootable OS image is ready. Your next step is to start is to start virtualbox

sudo virtualbox

Create your new virtual machine using virtual machine wizard. Virtual machine should have the following configuration because we are going to analyse the memory and my calculation will depend on this configuration.

 Select the myos.iso as your bootable image file and run it. This what you will see.

So finally we are done with this hello world program. I hope you enjoyed OSDEVING. Make sure you continue with it. We are going to do a lot more interesting stuff soon. Our next step is to analyse the memory we have and how to manage it. Will be back soon with the next tutorial.

HAPPY OSDEVING!!

"Hello World" Program!!! (Day 8)

In the last tutorial we didn't compile the C code. I'll give the commands for that in the next tutorial. For now you should save that file as kernel.c.

Now you have a the C part and an assembly part. What we need next is something which can link these two so that assembly code can call a C function. To link these we use linker.

Wikipedia definition:
A linker  is a computer program that takes one or more object files generated by a compiler and combines them into a single executable program. 

After compiling kernel.c and boot.s we will get object files kernel.o and boot.o. We are going to link these object files. To link these we need a linker script which tells how to link these files. The linker file is here.  Download the code and save it as linker.ld in same folder where kernel.c and boot.s reside.

Also read more about how to write a linker script and also find out what each part of the linker file means. Read more about linker here.

"Hello World" Program!!! (Writing C code!! Day 7) your own printf function

So let us start with a basic printf which will print hello world to the screen.
Remember that you can't use header files which you normally use in C programming (for example stdio.h) as they are not yet supported by the OS of this new system. But there are some header files which come with every compiler and standard across all type of compilers. In this case stddef.h stdint.h are two examples.
There is particular location in memory from which the data which needs to be displayed on the screen is read.
The memory location of this video buffer is stored in "buffer" variable.
Initially the assembly code calls kernel_main and the C code starts calling
Then we initialize screen to look black which is done in the cleanTheScreen() call
After which we call printf() which prints hello world to the screen.
Here you will see a lot of new data types which may be scary who have are still learning C programming. These new data types are used so that we are sure about the amount of space that is going to be allocated for these variables.

Make sure you write your own code which uses concepts explained in this code.
Following are the color code for various colors you can use in place of black and white we are using here in the code. BLACK = 0,
BLUE = 1,
GREEN = 2,
CYAN = 3,
RED = 4,
MAGENTA = 5,
BROWN = 6,
LIGHT GREY = 7,
DARK GREY = 8,
LIGHT BLUE = 9,
LIGHT GREEN = 10,
LIGHT CYAN = 11,
LIGHT RED = 12,
LIGHT MAGENTA = 13,
LIGHT BROWN = 14,
WHITE = 15,

#include 
#include 
//lets store the screen size in a global variable
static const size_t SCREEN_WIDTH = 80;
static const size_t SCREEN_HEIGHT = 24;
uint8_t screen_color = 0;//0x0
uint8_t text_color = 15;//0xf
uint16_t* buffer = (uint16_t*) 0xB8000;//pointer which points to the display memory. Display reads from this memory

int cleanTheScreen()
{
    size_t row = 0;
    size_t column = 0;
    char text = ' ';
    uint16_t color = screen_color;
    size_t position ;
    while(row < SCREEN_HEIGHT)
    {
        while(column < SCREEN_WIDTH)
        {
             position  = row*SCREEN_WIDTH+column;
             buffer[position] = text|screen_color<<8;
             column++;
        }
        row++;
    }
}
int printf(char* data,)
{
    uint8_t row = 0;
    uint8_t column = 0;
    size_t row = 0;
    size_t column = 0;
    char text = ' ';
    uint16_t color = text_color;
    size_t position ;
    while(column < SCREEN_WIDTH)
    {
         position  = row*SCREEN_WIDTH+column;
         buffer[position] = text|screen_color<<8;
         column++;
    }
}
void kernel_main()
{

 cleanTheScreen();
 printf();
}

"Hello World" Program!!! (Writing C code!! Day 6)

Finally something which we will understand clearly.... "C code". In the previous tutorial we wrote assembly code in which at the end there was a call kernel_main. This assembly code calls the kernel_main() function in the C program. This is where your c code starts executing.

As we had discussed earlier there will be no in built printf function or scanf function. You have to implement everything on your own. So before you get started you may want to have some tool to debug your code. Normally common people use printf to do that. But we don't have a printf function. So let us build a printf function first.

Few questions that may come up and they should actually:-

1. What things we need to print hello world on the screen?
2. What part of memory should we write the text to?
3. How to choose color?
4. What should we write?
5. OS which I am using right now has better looks what should I do to make my screen display content better?

We will go through these one by one!!! It would nice if you try to find answers to these questions on your own. Don't worry if you get answers. Answer to last question is an advanced topic which will be covered some time later.

"Hello World" Program!!! (Writing assembly code!! Day 5)

So from now on we will follow the steps mentioned in the previous post. Today we will write a bit of assembly code 

First few questions that came to my mind when I started writing the hello world program were
#)Why do we need assembly code!!??
#)Why cant we just start with C program?

Few reasons for these questions are:

1) You cannot enter protected mode with just C (I mentioned about protected mode in my previous posts).

2) Putting the multiboot header in the right section.
Multiboot header is something which tells the GRUB that  

3) setting up the stack etc. 

If you know other reasons please post them in the comment section.

Assembly code is here. You have to use the code from that page.  Save the code as "boot.s"
Then compile it using the following command. But this code wont compile It has errors. The code has error some where. Hence use this code instead.

#remember that every time you want to compile the code you develop you should set the environment variables in the terminal as given below

export PREFIX="$HOME/opt/cross"
export TARGET=i586-elf  
export TARGET=i586-elf 
export PATH="$PREFIX/bin:$PATH"

# The reason why you do this is because without these the computer will not  know which compiler to use and it will use your default compiler which is not meant to compile code for the new operating system you are developing.

#after these steps execute the following command after you cd to the folder which contains boot.s

i586-elf-as boot.s -o boot.o

For now and I think for a very long time you are free from this assembly language. You don't have to worry about this any more.

"Hello World" Program!!! (Day 4)

This post is quite late as compared to what I had planned. Developing and writing a tutorial is quite time consuming. You'll realize soon that OS development is quite tough and is not a child's play. You have to handle lot of errors which may or may not be discussed in this tutorials. But the satisfaction that you get once your code runs successfully for the first time is immense.

Before you write OS code you should know that you don't have basic functions like "printf" and "scanf". You have to write your own "printf",  "scanf" and many more functions (which you'll find is very interesting and you will learn a lot in this process). Another interesting thing is your program will directly interact with the hardware and you will have full control over the hardware unlike the programs you wrote for your college assignments.

So lets get started with our "hello world" program.

In this tutorial we are going to use GRUB as the boot loader. You can write your own bootloader but it requires a lot of knowledge of assembly language program. As our aim here is to cover more important concepts of OS, hence we will skip this step. If you wish to develop your own bootloader then you can refer to these websites.
1) GRUB official website.
2) OSDEV

GRUB:
GRUB is an excellent bootloader. It greatly simplifies the loading of operating system. It also provides us with many features which can be used in initializing the operating system. We will discuss about these features when we write the C code (step 2).

Steps that we are going to follow!!!
1) Write assembly code
2)  Write C code.
3) Compile them separately using the compiler we created earlier (refer to previous post).
4) Connect these two executable to create one single OS image.
5) Load this OS image on your virtualbox.
6) If everything is fine then you'll see your OS running.

This is how it will look after following all these steps :P

I hope this motivates you to go ahead with the tutorial :P

Building A cross compiler ( Day 3 )

What is a cross compiler?

A cross compiler is used to create executable for a platform which may be other than the platform on which the compiler is currently running.
To make thing clear:
If I have a machine A(64 bit machine) and I am using a compiler on it for developing OS which will run on machine B(32 bit machine) then the compiler that I am using has to be a cross compiler as it should create executable which will run on machine B.  

Why do you need a cross compiler?

If I use a compiler which runs on machine A(64 bit machine) then the executable produced by it may not run on machine B(32 bit  machine). Because instruction set for 64 bit machine can be differnt from a 32 bit machine. Hence we need a compiler that understands the instruction set which are compatible with machine B.

How do I build a cross compiler for the OS I am developing? 

Steps that must be followed:
1) open your terminal and execute the following commands.

cd ~
mkdir src

2) Download the following files to the "src" folder you just created in the previous step.

• binutils
• when you click on the link you will see a list of files. On that page you have to click on the link which is latest (date modified and version is mentioned there). Make sure you don't download a "patch" or ".sig" (Note that file size is in MB). 
• Note extensions to the file names indicate different compression techniques. All of them when uncompressed give the same file. You can download any compression provided both have same version. The only difference will be how much you download.
• gcc
• Its a two step job. First you follow the link. Then in that you click on the link which has latest version. That will lead you to yet another page. There you will get the download link for gcc. Download only one of the file mentioned on that page. Note do not download ".sig" or "diff" files, these files don't have gcc.
• gmp
• mpfr
• click on download and you will find the download link.
• mpc
• click on download and you will find the latest release. Download this latest release.

3) Extract all the files you downloaded in the step 2 to the same folder.

4) Execute the following commands:

cd ~
mkdir opt
cd opt
mkdir cross
export PREFIX="$HOME/opt/cross"
export TARGET=i586-elf
export PATH="$PREFIX/bin:$PATH"
cd $HOME/src
mkdir build-binutils
cd build-binutils
#note that "x.y.z" in the next command is its version number you have to replace it with that.
../binutils-x.y.z/configure --target=$TARGET --prefix="$PREFIX" --disable-nls
make
make install
cd $HOME/src
mv gmp-x.y.z gcc-x.y.z/gmp
mv mpfr-x.y.z gcc-x.y.z/mpfr
mv mpc-x.y.z gcc-x.y.z/mpc
mkdir build-gcc
cd build-gcc
../gcc-x.y.z/configure --target=$TARGET --prefix="$PREFIX" --disable-nls --enable-languages=c,c++ --without-headers
make all-gcc
make all-target-libgcc
make install-gcc
make install-target-libgcc

#there is high chance you may run into errors during this installation. Post your queries in the comment section or you can google them (obviously). Some times error can be solved by downloading a different file which has the same version but has a different compression (It happened in my case, dont know why!!!).

#If you don't run into any problem then CONGRATULATIONS your compiler is ready.

#in the next part of this tutorial we will write our first "hello world" OS.

#I recommend you folks to go through this page to understand the details. The explanation is good and most of the information in this tutorial is form that page.