Rishabh's posterous

Why you should never put your picture on the Internet ;)

Tue, 31 Jan 2012 21:57:32 -0800

Why you should never put your picture on the Internet.

See the full gallery on Posterous

Permalink | Leave a comment »

The Reason - Piano Cover

Thu, 03 Nov 2011 01:46:19 -0700

As promised, the piano version of The Reason by Hoobastank is here...

Permalink | Leave a comment »

RIP Steve Jobs

Wed, 05 Oct 2011 20:15:37 -0700

I'll always stay connected with Apple. I hope that throughout my life I'll sort of have the thread of my life and the thread of Apple weave in and out of each other, like a tapestry. There may be a few years when I'm not there, but I'll always come back

-- Steve Jobs, 1985-2011

Permalink | Leave a comment »

Bunjee Jumping :D

Thu, 29 Sep 2011 19:15:38 -0700

Me and Anurag free falling from 83 meters above ground :D

Permalink | Leave a comment »

Ye Raaste

Fri, 23 Sep 2011 11:08:00 -0700

Hi Everyone.. This is out next song release after "So Away". A lot of effort has been put in this song and hopefully it'll be like by everyone.

Here are the lyrics:

Ye Raste.. Le Jayenge Kahan Fir Hume..

Ye Manzilen.. Milwayengi Kis Kis Se Fir Hume..

Beete Jo Pal They, Wo Yaadein Ban Gaye..

Beete Wo Tum They, Jo Aansu Ban Gaye...

Un Aansuon Ko Hum, Phir Se Royenge...

Aur Un Palo Ko Hum, Phir Se Khoyenge...

Ye Raste.. Le Jayenge Kahan Fir Hume..

Ye Manzilen.. Milwayengi Kis Kis Se Fir Hume..

Tum Se Mile They, In Raahon Me Ek Din Hum...

Socha Nahi Tha.. Tum Ho Jaooge... Tu Gumm..

Parchhaiyan Hi.. Aaakhir Peeche Reh Gayin..

Lamhon Ko Sath Lekar... Hum Bhi Chal Diye...

In Rasto Pe.. Chalna Hai..

In Rasto Pe.....

Ye Nayee... Raaste...

Chhooti Thi Un Modo Par. .Kuchh.. Kahaniyan..

Baaten Thi Jo Bhi Ankaheen.. Thii.. Nishaniyaan..

Jaane Se Pehle. Mudke Dekha Na Ek Baar...

Karke Phir Ajnabee.... Yuuu.... Chal Diye...

Jin Rasto Pe.. Chalna They..

In Rasto Pe.....

Wo They Yeee... Raaste...

Ye Raste.. Le Jayenge Kahan Fir Hume..

Ye Manzilen.. Milwayengi Kis Kis Se Fir Hume..

Beete Jo Pal They, Wo Yaadein Ban Gaye..

Beete Wo Tum They, Jo Aansu Ban Gaye...

Un Aansuon Ko Hum, Phir Se Royenge...

Aur Un Palo Ko Hum, Phir Se Khoyenge...

Ye Raste.. Le Jayenge Kahan Fir Hume..

Ye Manzilen.. Milwayengi Kis Kis Se Fir Hume..

For High Quality Audio Download, Check Out: https://www.facebook.com/RishPhotography/posts/268490886508970

Permalink | Leave a comment »

Here Without You : Piano Version

Sat, 10 Sep 2011 22:27:22 -0700

Hi Quality mp3 download: http://soundcloud.com/rishh/here-without-you

Permalink | Leave a comment »

Aadha Ishq, Piano Acoustic Version

Mon, 29 Aug 2011 23:57:00 -0700

Here's something definitely not related to photography, but one of those things I absolutely love :)

Aadha Ishq by Shreya Ghoshal, Piano Acoustic Version

High Quality Audio Available At http://soundcloud.com/rishh/aadha-ishq

On Facebook

Permalink | Leave a comment »

Probably The Best National Anthem Video

Mon, 15 Aug 2011 00:58:09 -0700

Permalink | Leave a comment »

Mind = Blown

Sat, 13 Aug 2011 04:31:18 -0700

Permalink | Leave a comment »

50 Things | MIT Admissions

Mon, 11 Jul 2011 12:21:00 -0700

Dear Class of 2010,

This will be my last entry written specifically for you; beginning with the launch of our new site in early September, I'll begin focusing on the future class of 2011. I hope that you guys won't be strangers; stay in touch either in person (come visit us!) or online (please drop by the blogs from time to time and say hi).

As you begin your college experience, and I prepare for my 10-year college reunion, I thought I'd leave you with the things that, in retrospect, I think are important as you navigate the next four years. I hope that some of them are helpful.

Here goes...

Your friends will change a lot over the next four years. Let them.

Call someone you love back home a few times a week, even if just for a few minutes.

In college more than ever before, songs will attach themselves to memories. Every month or two, make a mix cd, mp3 folder, whatever - just make sure you keep copies of these songs. Ten years out, they'll be as effective as a journal in taking you back to your favorite moments.

Take naps in the middle of the afternoon with reckless abandon.

Adjust your schedule around when you are most productive and creative. If you're nocturnal and do your best work late at night, embrace that. It may be the only time in your life when you can.

If you write your best papers the night before they are due, don't let people tell you that you "should be more organized" or that you "should plan better." Different things work for different people. Personally, I worked best under pressure - so I always procrastinated... and always kicked ass (which annoyed my friends to no end). ;-) Use the freedom that comes with not having grades first semester to experiment and see what works best for you.

At least a few times in your college career, do something fun and irresponsible when you should be studying. The night before my freshman year psych final, my roommate somehow scored front row seats to the Indigo Girls at a venue 2 hours away. I didn't do so well on the final, but I haven't thought about psych since 1993. I've thought about the experience of going to that show (with the guy who is now my son's godfather) at least once a month ever since.

Become friends with your favorite professors. Recognize that they can learn from you too - in fact, that's part of the reason they chose to be professors.

Carve out an hour every single day to be alone. (Sleeping doesn't count.)

Go on dates. Don't feel like every date has to turn into a relationship.

Don't date someone your roommate has been in a relationship with.

When your friends' parents visit, include them. You'll get free food, etc., and you'll help them to feel like they're cool, hangin' with the hip college kids.

In the first month of college, send a hand-written letter to someone who made college possible for you and describe your adventures thus far. It will mean a lot to him/her now, and it will mean a lot to you in ten years when he/she shows it to you.

Embrace the differences between you and your classmates. Always be asking yourself, "what can I learn from this person?" More of your education will come from this than from any classroom.

All-nighters are entirely overrated.

For those of you who have come to college in a long-distance relationship with someone from high school: despite what many will tell you, it can work. The key is to not let your relationship interfere with your college experience. If you don't want to date anyone else, that's totally fine! What's not fine, however, is missing out on a lot of defining experiences because you're on the phone with your boyfriend/girlfriend for three hours every day.

Working things out between friends is best done in person, not over email. (IM does not count as "in person.") Often someone's facial expressions will tell you more than his/her words.

Take risks.

Don't be afraid of (or excited by) the co-ed bathrooms. The thrill is over in about 2 seconds.

Wednesday is the middle of the week; therefore on wednesday night the week is more than half over. You should celebrate accordingly. (It makes thursday and friday a lot more fun.)

Welcome failure into your lives. It's how we grow. What matters is not that you failed, but that you recovered.

Take some classes that have nothing to do with your major(s), purely for the fun of it.

It's important to think about the future, but it's more important to be present in the now. You won't get the most out of college if you think of it as a stepping stone.

When you're living on a college campus with 400 things going on every second of every day, watching TV is pretty much a waste of your time and a waste of your parents' money. If you're going to watch, watch with friends so at least you can call it a "valuable social experience."

Don't be afraid to fall in love. When it happens, don't take it for granted. Celebrate it, but don't let it define your college experience.

Much of the time you once had for pleasure reading is going to disappear. Keep a list of the books you would have read had you had the time, so that you can start reading them when you graduate.

Things that seem like the end of the world really do become funny with a little time and distance. Knowing this, forget the embarassment and skip to the good part.

Every once in awhile, there will come an especially powerful moment when you can actually feel that an experience has changed who you are. Embrace these, even if they are painful.

No matter what your political or religious beliefs, be open-minded. You're going to be challenged over the next four years in ways you can't imagine, across all fronts. You can't learn if you're closed off.

If you need to get a job, find something that you actually enjoy. Just because it's work doesn't mean it has to suck.

Don't always lead. It's good to follow sometimes.

Take a lot of pictures. One of my major regrets in life is that I didn't take more pictures in college. My excuse was the cost of film and processing. Digital cameras are cheap and you have plenty of hard drive space, so you have no excuse.

Your health and safety are more important than anything.

Ask for help. Often.

Half of you will be in the bottom half of your class at any given moment. Way more than half of you will be in the bottom half of your class at some point in the next four years. Get used to it.

In ten years very few of you will look as good as you do right now, so secretly revel in how hot you are before it's too late.

In the long run, where you go to college doesn't matter as much as what you do with the opportunities you're given there. The MIT name on your resume won't mean much if that's the only thing on your resume. As a student here, you will have access to a variety of unique opportunities that no one else will ever have - don't waste them.

On the flip side, don't try to do everything. Balance = well-being.

Make perspective a priority. If you're too close to something to have good perspective, rely on your friends to help you.

Eat badly sometimes. It's the last time in your life when you can do this without feeling guilty about it.

Make a complete ass of yourself at least once, preferably more. It builds character.

Wash your sheets more than once a year. Trust me on this one.

If you are in a relationship and none of your friends want to hang out with you and your significant other, pay attention. They usually know better than you do.

Don't be afraid of the weird pizza topping combinations that your new friend from across the country loves. Some of the truly awful ones actually taste pretty good. Expand your horizons.

Explore the campus thoroughly. Don't get caught.

Life is too short to stick with a course of study that you're no longer excited about. Switch, even if it complicates things.

Tattoos are permanent. Be very certain.

Don't make fun of prefrosh. That was you like 2 hours ago.

Enjoy every second of the next four years. It is impossible to describe how quickly they pass.

This is the only time in your lives when your only real responsibility is to learn. Try to remember how lucky you are every day.

via mitadmissions.org

Permalink | Leave a comment »

So Away - The Video :)

Thu, 23 Jun 2011 23:01:00 -0700

And we have a review on it too :) http://milz.posterous.com/so-away-my-personal-review

Permalink | Leave a comment »

My Immortal: Piano Cover

Tue, 14 Jun 2011 15:17:06 -0700

Permalink | Leave a comment »

So Away [The Video] - Coming Soon

Mon, 13 Jun 2011 15:25:16 -0700

Permalink | Leave a comment »

University life

Thu, 02 Jun 2011 09:03:43 -0700

Every New semester:

After 1st week:

After the 2nd week:

Before the mid-term test:

During the mid-term test:

After the mid-term test:

Before the final exam:

Once get to know the final exam schedule:

7 days before the final exam:

6 days before the final exam:

5 days before the final exam:

4 days before the final exam:

3 days before the final exam:

2 days before the final exam:

1 day before the final exam:

The night before the final exam:

1 hour before the final exam:

During the final exam:

Once walk out from the examination hall:

After the final exam, during the holiday:

That's university!!

__._,

Permalink | Leave a comment »

How Apple Keyboards Lost a Logo and Windows PCs Gained One

Tue, 17 May 2011 14:16:00 -0700

via roughlydrafted.com

Very Interesting. And for the ones who notice every detail

Permalink | Leave a comment »

Ring My Bells Intro Piano

Sat, 07 May 2011 03:36:09 -0700

ring_my_bells_intro.mp3 Listen on Posterous

Just Recorded :)

Permalink | Leave a comment »

I Made A Song :)

Thu, 14 Apr 2011 05:18:00 -0700

So Away by Rishabh & Ritu Listen on Posterous

This is my first song. Written and composed by me and sung by me and my sister.

Hope you like it :)

Thanks!

Here are the lyrics to the song as well:

Everytime I see my face..

Everytime I see this place...

EVerytime I see my face..

Everytime I see this place...

Everytime this rain, comes and goes

away...

Everytime I walk this way..

I try to breathe..

I try to sleep..

I try to break myself away...

Away... So Away...

People meet, they come and go..

Falling leaves, and melting snow..

Bring your memories, to my heart

and soul..

I wish you were not, So away...

Away... So Away...

And the promises that you made...

And the memories that you gave..

That's all I have..

And you went away...

The stars in your eyes..

And those in the sky..

They all are gone..

With you away....

wo ho wooo.. wo ho wooo...

You're so away...

wo ho wooo.. wo ho wooo...

You're so away...

PS: You can download the song directly from http://soundcloud.com/rishh/so-away

On Tumblr: http://life.rishabhagarwal.com/post/4605370259/this-is-my-first-song-written-and-composed-by-me

Permalink | Leave a comment »

Scenes from last night! « The Thoughtcrime

Thu, 31 Mar 2011 02:07:00 -0700

via thethoughtcrime.com

ROFL! :D :D :D

Permalink | Leave a comment »

Just Like That: Facebook Relationship Status Options

Thu, 17 Feb 2011 02:41:00 -0800

via smilejustlikethat.blogspot.com

Haha!

Permalink | Leave a comment »

How to write a simple operating system in assembly language

Sat, 29 Jan 2011 01:02:00 -0800

How to write a simple operating system

(C) 2009 Mike Saunders and MikeOS Developers

This document shows you how to write and build your first operating system in x86 assembly language. It explains what you need, the fundamentals of the PC boot process and assembly language, and how to take it further. The resulting OS will be very small (fitting into a bootloader) and have very few features, but it's a starting point for you to explore further.

After you have read the guide, see the MikeOS project for a bigger x86 assembly language OS that you can explore to expand your skills.

Requirements

Prior programming experience is essential. If you've done some coding in a high-level language like PHP or Java, that's good, but ideally you'll have some knowledge of a lower-level language like C, especially on the subject of memory and pointers.

For this guide we're using Linux. OS development is certainly possible on Windows, but it's so much easier on Linux as you can get a complete development toolchain in a few mouse-clicks/commands. Linux is also really good for making floppy disk and CD-ROM images - you don't need to install loads of fiddly programs.

Installing Linux is very easy thesedays; grab Ubuntu and install it in VMware or VirtualBox if you don't want to dual-boot. When you're in Ubuntu, get all the tools you need to follow this guide by entering this in a terminal window:
sudo apt-get install build-essential qemu nasm
This gets you the development toolchain (compiler etc.), QEMU PC emulator and the NASM assembler, which converts assembly language into raw machine code executable files.

PC primer

If you're writing an OS for x86 PCs (the best choice, due to the huge amount of documentation available), you'll need to understand the basics of how a PC starts up. Fortunately, you don't need to dwell on complicated subjects such as graphics drivers and network protocols, as you'll be focusing on the essential parts first.

When a PC is powered-up, it starts executing the BIOS (Basic Input/Output System), which is essentially a mini-OS built into the system. It performs a few hardware tests (eg memory checks) and typically spurts out a graphic (eg Dell logo) or diagnostic text to the screen. Then, when it's done, it starts to load your operating system from any media it can find. Many PCs jump to the hard drive and start executing code they find in the Master Boot Record (MBR), a 512-byte section at the start of the hard drive; some try to find executable code on a floppy disk (boot sector) or CD-ROM.

This all depends on the boot order - you can normally specify it in the BIOS options screen. The BIOS loads 512 bytes from the chosen media into its memory, and begins executing it. This is the bootloader, the small program that then loads the main OS kernel or a larger boot program (eg GRUB/LILO for Linux systems). This 512 byte bootloader has two special numbers at the end to tell the OS that it's a boot sector - we'll cover that later.

Note that PCs have an interesting feature for booting. Historically, most PCs had a floppy drive, so the BIOS was configured to boot from that device. Today, however, many PCs don't have a floppy drive - only a CD-ROM - so a hack was developed to cater for this. When you're booting from a CD-ROM, it can emulate a floppy disk; the BIOS reads the CD-ROM drive, loads in a chunk of data, and executes it as if it was a floppy disk. This is incredibly useful for us OS developers, as we can make floppy disk versions of our OS, but still boot it on CD-only machines. (Floppy disks are really easy to work with, whereas CD-ROM filesystems are much more complicated.)

So, to recap, the boot process is:

Power on: the PC starts up and begins executing the BIOS code.

The BIOS looks for various media such as a floppy disk or hard drive.

The BIOS loads a 512 byte boot sector from the specified media and begins executing it.

Those 512 bytes then go on to load the OS itself, or a more complex bootloader.

For MikeOS, we have the 512-byte bootloader, which we write to a floppy disk image file (a virtual floppy). We can then inject that floppy image into a CD, for PCs that only have CD-ROM drives. Either way, the BIOS loads it as if it was on a floppy, and starts executing it. We have control of the system!

Assembly language primer

Most modern operating systems are written in C/C++. That's very useful when portability and code-maintainability are crucial, but it adds an extra layer of complexity to the proceedings. For your very first OS, you're better off sticking with assembly language, as used in MikeOS. It's more verbose and non-portable, but you don't have to worry about compilers and linkers. Besides, you need a bit of assembly to kick-start any OS.

Assembly language (or colloquially "asm") is a textual way of representing the instructions that a CPU executes. For instance, an instruction to move some memory in the CPU may be 11001001 01101110 - but that's hardly memorable! So assembly provides mnemonics to substitute for these instructions, such as mov ax, 30. They correlate directly with machine-code CPU instructions, but without the meaningless binary numbers.

Like most programming languages, assembly is a list of instructions followed in order. You can jump around between various places and set up subroutines/functions, but it's much more minimal than C# and friends. You can't just print "Hello world" to the screen - the CPU has no concept of what a screen is! Instead, you work with memory, manipulating chunks of RAM, performing arithmetic on them and putting the results in the right place. Sounds scary? It's a bit alien at first, but it's not hard to grasp.

At the assembly language level, there is no such thing as variables in the high-level language sense. What you do have, however, is a set of registers, which are on-CPU memory stores. You can put numbers into these registers and perform calculations on them. In 16-bit mode, these registers can hold numbers between 0 and 65535. Here's a list of the fundamental registers on a typical x86 CPU:

AX, BX, CX, DX General-purpose registers for storing numbers that you're using. For instance, you may use AX to store the character that has been pressed on the keyboard, while using CX to act as a counter in a loop. (Note: these 16-bit registers can be split into 8-bit registers such as AH/AL, BH/BL etc.)

SI, DI Source and destination data index registers. These point to places in memory for retrieving and storing data.

SP The Stack Pointer (explained in a moment).

IP (sometimes CP) The Instruction/Code Pointer. This contains the location in memory of the instruction being executed. When an instruction has finished, it is incremented and moves on to the next instruction. You can change the contents of this register to move around in your code.

So you can use these registers to store numbers as you work - a bit like variables, but they're much more fixed in size and purpose. There are a few others, notably segment registers. Due to limitations in old PCs, memory was handled in 64K chunks called segments. This is a really messy subject, but thankfully you don't have to worry about it - for the time being, your OS will be less than a kilobyte anyway! In MikeOS, we limit ourselves to a single 64K segment so that we don't have to mess around with segment registers.

The stack is an area of your main RAM used for storing temporary information. It's called a stack because numbers are stacked one-on-top of another. Imagine a Pringles tube: if you put in a playing card, an iPod Shuffle and a beermat, you'll pull them out in the reverse order (beermat, then iPod, and finally playing card). It's the same with numbers: if you push the numbers 5, 7 and 15 onto the stack, you will pop them out as 15 first, then 7, and lastly 5. In assembly, you can push registers onto the stack and pop them out later - it's useful when you want to store temporarily the value of a register while you use that register for something else.

PC memory can be viewed as a linear line of pigeon-holes ranging from byte 0 to whatever you have installed (millions of bytes on modern machines). At byte number 53,634,246 in your RAM, for instance, you may have your web browser code to view this document. But whereas we humans count in powers of 10 (10, 100, 1000 etc. - decimal), computers are better off with powers of two (because they're based on binary). So we use hexadecimal, which is base 16, as a way of representing numbers. See this chart to understand:

Decimal 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20

Hexadecimal 0 1 2 3 4 5 6 7 8 9 A B C D E F 10 11 12 13 14

As you can see, whereas our normal decimal system uses 0 - 9, hexadecimal uses 0 - F in counting. It's a bit weird at first, but you'll get the hang of it. In assembly programming, we identify hexadecimal (hex) numbers by tagging a 'h' onto the end - so 0Ah is hex for the number 10. (You can also denote hexadecimal in assembly by prefixing the number with 0x - for instance, 0x0A.)

Let's finish off with a few common assembly instructions. These move memory around, compare them and perform calculations. They're the building blocks of your OS - there are hundreds of instructions, but you don't have to memorise them all, because the most important handful are used 90% of the time.

mov Copies memory from one location or register to another. For instance, mov ax, 30 places the number 30 into the AX register. Using square brackets, you can get the number at the memory location pointed to by the register. For instance, if BX contains 80, then mov ax, [bx] means "get the number in memory location 80, and put it into AX". You can move numbers between registers too: mov bx, cx.

add / sub Adds a number to a register. add ax, FFh adds FF in hexadecimal (255 in our normal decimal) to the AX register. You can use sub in the same way: sub dx, 50.

cmp Compares a register with a number. cmp cx, 12 compares the CX register with the number 12. It then updates a special register on the CPU called FLAGS - a special register that contains information about the last operation. In this case, if the number 12 is bigger than the value in CX, it generates a negative result, and notes that negative in the FLAGS register. We can use this in the following instructions...

jmp / jg / jl... Jump to a different part of the code. jmp label jumps (GOTOs) to the part of our source code where we have label: written. But there's more - you can jump conditionally, based on the CPU flags set in the previous command. For instance, if a cmp instruction determined that a register held a smaller value than the one with which it was compared, you can act on that with jl label (jump if less-than to label). Similarly, jge label jumps to 'label' in the code if the value in the cmp was greater-than or equal to its compared number.

int Interrupt the program and jump to a specified place in memory. Operating systems set up interrupts which are analogous to subroutines in high-level languages. For instance, in MS-DOS, the 21h interrupt provides DOS services (eg as opening a file). Typically, you put a value in the AX register, then call an interrupt and wait for a result (passed back in a register too). When you're writing an OS from scratch, you can call the BIOS with int 10h, int 13h, int 14h or int 16h to perform tasks like printing strings, reading sectors from a floppy disk etc.

Let's look at some of these instructions in a little more detail. Consider the following code snippet:
mov bx, 1000h
        mov ax, [bx]
        cmp ax, 50
        jge label
        ...

label:
        mov ax, 10
In the first instruction, we move the number 1000h into the BX register. Then, in the second instruction, we store in AX whatever is in the memory location pointed to by BX. This is what the [bx] means: if we just did mov ax, bx it'd simply copy the number 1000h into the AX register. But by using square brackets, we're saying: don't just copy the contents of BX into AX, but copy the contents of the memory address to which BX points. Given that BX contains 1000h, this instruction says: find whatever is at memory location 1000h, and put it into AX.

So, if the byte of memory at location 1000h contains 37, then that number 37 will be put into the AX register via our second instruction. Next up, we use cmp to compare the number in AX with the number 50 (the decimal number 50 - we didn't suffix it with 'h'). The following jge instruction acts on the cmp comparison, which has set the FLAGS register as described earlier. The jge label says: if the result from the previous comparison is greater than or equal, jump to the part of the code denoted by label:. So if the number in AX is greater than or equal to 50, execution jumps to label:. If not, execution continues at the '...' stage.

One last thing: you can insert data into a program with the db (define byte) directive. For instance, this defines a series of bytes with the number zero at the end, representing a string:
mylabel: db 'Message here', 0
In our assembly code, we know that a string of characters, terminated by a zero, can be found at the mylabel: position. We could also set up single byte to use somewhat like a variable:
foo: db 0
Now foo: points at a single byte in the code, which in the case of MikeOS will be writable as the OS is copied completely to RAM. So you could have this instruction:
mov byte al, [foo]
This moves the byte pointed to by foo into the AL register.

That's the essentials of x86 PC assembly language, and enough to get you started. When writing an OS, though, you'll need to learn much more as you progress, so see the Resources section for links to more in-depth assembly tutorials.

Your first OS

Now you're ready to write your first operating system kernel! Of course, this is going to be extremely bare-bones, just a 512-byte boot sector as described earlier, but it's a starting point for you to expand further. Paste the following code into a file called myfirst.asm and save it into your home directory - this is the source code to your first OS.
BITS 16

start:
        mov ax, 07C0h                ; Set up 4K stack space after this bootloader
        add ax, 288                ; (4096 + 512) / 16 bytes per paragraph
        mov ss, ax
        mov sp, 4096

        mov ax, 07C0h                ; Set data segment to where we're loaded
        mov ds, ax


        mov si, text_string        ; Put string position into SI
        call print_string        ; Call our string-printing routine

        jmp $                        ; Jump here - infinite loop!


        text_string db 'This is my cool new OS!', 0


print_string:                        ; Routine: output string in SI to screen
        mov ah, 0Eh                ; int 10h 'print char' function

.repeat:
        lodsb                        ; Get character from string
        cmp al, 0
        je .done                ; If char is zero, end of string
        int 10h                        ; Otherwise, print it
        jmp .repeat

.done:
        ret


        times 510-($-$$) db 0        ; Pad remainder of boot sector with 0s
        dw 0xAA55                ; The standard PC boot signature
Let's step through this. The BITS 16 line isn't an x86 CPU instruction; it just tells the NASM assembler that we're working in 16-bit mode. NASM can then translate the following instructions into raw x86 binary. Then we have the start: label, which isn't strictly needed as execution begins right at the start of the file anyway, but it's a good marker. From here onwards, note that the semicolon (;) character is used to denote non-executable text comments - we can put anything there.

The following six lines of code aren't really of interest to us - they simply set up the segment registers so that the stack pointer (SP) knows where our handy stack of temporary data is, and where the data segment (DS) is located. As mentioned, segments are a hideously messy way of handling memory from the old 16-bit days, but we just set up the segment registers and forget about them. (The references to 07C0h are the equivalent segment location at which the BIOS loads our code, so we start from there.)

The next part is where the fun happens. The mov si, text_string line says: copy the location of the text string below into the SI register. Simple enough! Then we use call, which is like a GOSUB in BASIC or a function call in C. It means: jump to the specified section of code, but prepare to come back here when we're done.

How does the code know how to do that? Well, when we use a call instruction, the CPU increments the position of the IP (Instruction Pointer) register and pushes it onto the stack. You may recall from the previous explanation of the stack that it's a last-in first-out memory storage mechanism. All that business with the stack pointer (SP) and stack segment (SS) at the start cleared a space for the stack, so that we can drop temporary numbers there without overwriting our code.

So, the call print_string says: jump to the print_string routine, but push the location of the next instruction onto the stack, so we can pop it off later and resume execution here. Execution has jumped over to print_string: - this routine uses the BIOS to output text to the screen. First we put 0Eh into the AH register (the upper byte of AX). Then we have a lodsb (load string byte) instruction, which retrieves a byte of data from the location pointed to by SI, and stores it in AL (the lower byte of AX). Next we use cmp to check if that byte is zero - if so, it's the end of the string and we quit printing (jump to the .done label).

If it's not zero, we call int 10h (interrupt our code and go to the BIOS), which reads the value in the AH register (0Eh) we set up before. Ah, says the BIOS - 0Eh in the AH register means "print the character in the AL register to the screen!". So the BIOS prints the first character in our string, and returns from the int call. We then jump to the .repeat label, which starts the process again - lodsb to load the next byte from SI (it increments SI each time), see if it's zero and decide what to do. The ret at the end of our string-printing routine means: "we've finished here - return back to the place where we were called by popping the code location from the stack back into the IP register".

So there we have a demonstration of a loop, in a standalone routine. You can see that the text_string label is alongside a stream of characters, which we insert into our OS using db. The text is in apostrophes so that NASM knows it's not code, and at the end we have a zero to tell our print_string routine that we're at the end.

Let's recap: we start off by setting up the segment registers so that our OS knows where the stack pointer and executable code resides. Then we point the SI register at a string in our OS binary, and call our string-printing routine. This routine scans through the characters pointed to by SI and displays them until it finds a zero, at which point it returns back into the code that called it. Then the jmp $ line says: keep jumping to the same line. (The '$' in NASM denotes the current point of code.) This sets up an infinite loop, so that the message is displayed and our OS doesn't try to execute the following string!

The final two lines are interesting. For a PC to recognise a valid floppy disk boot sector, it has to be exactly 512 bytes in size and end with the numbers AAh and 55h (the boot signature). So the first of these lines says: pad out our resulting binary file to be 510 bytes in size. Then the second line uses dw (define a word - two bytes) containing the aforementioned boot signature. Voila: a 512 byte boot file with the correct numbers at the end for the BIOS to recognise.

Let's build our new OS. In a terminal window, in your home directory, enter:
nasm -f bin -o myfirst.bin myfirst.asm
Here we assemble the code from our text file into a raw binary file of machine-code instructions. With the -f bin flag, we tell NASM that we want a plain binary file (not a complicated Linux executable - we want it as plain as possible!). The -o myfirst.bin part tells NASM to generate the resulting binary in a file called myfirst.bin.

Now we need a virtual floppy disk image to which we can write our bootloader-sized kernel. Copy mikeos.flp from the disk_images/ directory of the MikeOS bundle into your home directory, and rename it myfirst.flp. Then enter:
dd status=noxfer conv=notrunc if=myfirst.bin of=myfirst.flp
This uses the 'dd' utility to directly copy our kernel to the first sector of the floppy disk image. When it's done, we can boot our new OS using the QEMU PC emulator as follows:
qemu -fda myfirst.flp
And there you are! Your OS will boot up in a virtual PC. If you want to use it on a real PC, you can write the floppy disk image to a real floppy and boot from it, or generate a CD-ROM ISO image. For the latter, make a new directory called cdiso and move the myfirst.flp file into it. Then, in your home directory, enter:
mkisofs -o myfirst.iso -b myfirst.flp cdiso/
This generates a CD-ROM ISO image called myfirst.iso with bootable floppy disk emulation, using the virtual floppy disk image from before. Now you can burn that ISO to a CD-R and boot your PC from it! (Note that you need to burn it as a direct ISO image and not just copy it onto a disc.)

Next you'll want to improve your OS - explore the MikeOS source code to get some inspiration. Remember that bootloaders are limited to 512 bytes, so if you want to do a lot more, you'll need to make your bootloader load a separate file from the disk and begin executing it, in the same fashion as MikeOS.

Going further

So, you've now got a very simple bootloader-based operating system running. What next? Here's some ideas:

Add more routines -- You already have print_string in your kernel. You could add routines to get strings, move the cursor etc. Search the internet for BIOS calls which you can use to achieve these.

Load files -- The bootloader is limited to 512 bytes, so you don't have much room. You could make the bootloader load subsequent sectors on the disk into RAM, and jump to that point to continue execution. Or you could read up on FAT12, the filesystem used on floppy drives, and implement that. (See source/bootload/bootload.asm in the MikeOS .zip for an implementation.

Join another project -- This tutorial was written by Mike Saunders, the lead developer of MikeOS. It's a simple 16-bit x86 assembly language operating system, and once you're fully confident with the concepts covered here, you'll be able to dig into the code and add features. See the System Developer Handbook link on the front page for more info, and join the mailing list!

via mikeos.berlios.de

Permalink | Leave a comment »

AX, BX, CX, DX	General-purpose registers for storing numbers that you're using. For instance, you may use AX to store the character that has been pressed on the keyboard, while using CX to act as a counter in a loop. (Note: these 16-bit registers can be split into 8-bit registers such as AH/AL, BH/BL etc.)
SI, DI	Source and destination data index registers. These point to places in memory for retrieving and storing data.
SP	The Stack Pointer (explained in a moment).
IP (sometimes CP)	The Instruction/Code Pointer. This contains the location in memory of the instruction being executed. When an instruction has finished, it is incremented and moves on to the next instruction. You can change the contents of this register to move around in your code.

Decimal	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15	16	17	18	19	20
Hexadecimal	0	1	2	3	4	5	6	7	8	9	A	B	C	D	E	F	10	11	12	13	14

mov	Copies memory from one location or register to another. For instance, mov ax, 30 places the number 30 into the AX register. Using square brackets, you can get the number at the memory location pointed to by the register. For instance, if BX contains 80, then mov ax, [bx] means "get the number in memory location 80, and put it into AX". You can move numbers between registers too: mov bx, cx.
add / sub	Adds a number to a register. add ax, FFh adds FF in hexadecimal (255 in our normal decimal) to the AX register. You can use sub in the same way: sub dx, 50.
cmp	Compares a register with a number. cmp cx, 12 compares the CX register with the number 12. It then updates a special register on the CPU called FLAGS - a special register that contains information about the last operation. In this case, if the number 12 is bigger than the value in CX, it generates a negative result, and notes that negative in the FLAGS register. We can use this in the following instructions...
jmp / jg / jl...	Jump to a different part of the code. jmp label jumps (GOTOs) to the part of our source code where we have label: written. But there's more - you can jump conditionally, based on the CPU flags set in the previous command. For instance, if a cmp instruction determined that a register held a smaller value than the one with which it was compared, you can act on that with jl label (jump if less-than to label). Similarly, jge label jumps to 'label' in the code if the value in the cmp was greater-than or equal to its compared number.
int	Interrupt the program and jump to a specified place in memory. Operating systems set up interrupts which are analogous to subroutines in high-level languages. For instance, in MS-DOS, the 21h interrupt provides DOS services (eg as opening a file). Typically, you put a value in the AX register, then call an interrupt and wait for a result (passed back in a register too). When you're writing an OS from scratch, you can call the BIOS with int 10h, int 13h, int 14h or int 16h to perform tasks like printing strings, reading sectors from a floppy disk etc.