Write Bootloader in C

问题:

I am a newbie in writing bootloaders. I have written a helloworld bootloader in asm, and I am now trying to write one in C. I have written a helloworld bootloader in C, but I cannot compile it.

This is my code. What am I doing wrong? Am I taking the wrong approach entirely?

void print_char();
int main(void){
char *MSG = "Hello World!";
int i;

__asm__(
    "mov %0, %%SI;"
    :
    :"g"(MSG)
);
for(i=0;i<12;i++){
    __asm__(
        "mov %0, %%AL;"
        :
        :"g"(MSG[i])
    );
    print_char();
}

return 0;
}

void print_char(){
__asm__(
    "mov $0X0E, %AH;"
    "mov $0x00, %BH;"
    "mov $0x04, %BL;"
    "int $0x10"
);
}

回答1:

I would suggest you to have a look at http://wiki.osdev.org/Rolling_Your_Own_Bootloader and also the Bootloader section of : http://www.brokenthorn.com/Resources/OSDevIndex.html

There are excellent tutorials to get yourself started to make yourself your own bootloader. Also you can join the #osdev channel in freenode to join a discussion if you need more information.

回答2:

Let me assume a lot of things here: you want to run your bootloader on an x86 system, you have the gcc toolchain set up on a *nix box.

There are some points to be taken into account when writing a bootloader:

1. the 510 byte limit for a VBR, even lesser for MBR due to partition table (if your system needs one)
2. real mode - 16 bit registers and seg:off addressing
3. bootloader must be flat binary that must be linked to run at physical address 7c00h
4. no external 'library' references (duh!)

now if you want gcc to output such a binary, you need to play some tricks with it.

1. gcc by default splits out 32bit code. To have gcc output code that would run in real mode, add __asm__(".code16gcc\n") at the top of each C file.

2. gcc outputs compiled objects in ELF. We need a bin that is statically linked at 7c00h. Create a file linker.ld with following contents

   ENTRY(main);
   SECTIONS
   {    
       . = 0x7C00;    
       .text : AT(0x7C00)
       {
           _text = .;
           *(.text);
           _text_end = .;
       }
       .data :
       {
           _data = .;
           *(.bss);
           *(.bss*);
           *(.data);
           *(.rodata*);
           *(COMMON)
           _data_end = .;
       }    
       .sig : AT(0x7DFE)    
       {        
           SHORT(0xaa55);
       }    
       /DISCARD/ :
       {
           *(.note*);
           *(.iplt*);
           *(.igot*);
           *(.rel*);
           *(.comment);
           /* add any unwanted sections spewed out by your version of gcc and flags here */    
       }
   }
   

3. write your bootloader code in bootloader.c and build the bootloader

   $ gcc -c -g -Os -march=i686 -ffreestanding -Wall -Werror -I. -o bootloader.o bootloader.c
   $ ld -static -Tlinker.ld -nostdlib --nmagic -o bootloader.elf bootloader.o
   $ objcopy -O binary bootloader.elf bootloader.bin
   

4. Since you already have built boot loaders with ASM, I guess the rest is obvious to you.

- taken from my blog: http://dc0d32.blogspot.in/2010/06/real-mode-in-c-with-gcc-writing.html

回答3:

A bootloader is written in ASM.

When compiling C code (or C++, or whatever), a compiler will 'transform' your human readable code into machine code. So you can't be sure about the result.

When a PC boots, the BIOS will execute code from a specific address. That code needs to be executable, directly.

That's why you'll use assembly. It's the only way to have un-altered code, that will be run as written, by the processor.

If you want to code in C, you'll still have to code an ASM bootloader, which will be in charge to load properly the machine code generated by the compiler you use.

You need to understand that each compiler will generate different machine codes, that may need pre-processing before execution.

The BIOS won't let you pre-process your machine code. The PC boot is just a jump to a memory location, meaning the machine code located at this location will be directly executed.

回答4:

Since you are using GCC, you should read the info pages about the different "target environments". You most probably want to use the -ffreestanding flag. Also I had to use -fno-stack-protector flags to avoid some ugly magic of the compiler.

Then, you will get linker errors saying that memset and the like are not found. So you should implement your own version of these and link them in.

回答5:

I tried this a few years ago -- options may have changed.

You have to run gcc with -ffreestanding (don't link) and then link using ld with the flags -static, -nostdlib