lazymonkey posted @ 2012年5月12日 00:59 in 操作系统 with tags GeekOS , 3488 阅读



和Project0一样,Project1在make depend && make时,也会有错误提示,一步一步来解决:

0.去掉过于严格的编译选项(line 178):




1.去掉gcc栈保护的选项(line 176):



GENERAL_OPTS := -O -Wall -fno-stack-protector $(EXTRA_C_OPTS)


# An example .bochsrc file.
# You will need to edit these lines to reflect your system.
vgaromimage: file=/usr/share/bochs/VGABIOS-lgpl-lates
romimage: file=/usr/share/bochs/BIOS-bochs-latest
megs: 8
boot: a
floppya: 1_44=fd.img, status=inserted
#floppya: 1_44=fd_aug.img, status=inserted
log: ./bochs.out
keyboard_serial_delay: 200
vga_update_interval: 300000
mouse: enabled=0
private_colormap: enabled=0
i440fxsupport: enabled=0
# Uncomment this to write all bochs debugging messages to
# bochs.out.  This produces a lot of output, but can be very
# useful for debugging the kernel.
#debug: action=report



$ man bochsrc


ata0: , ata1: , ata2: or ata3:

          These options enables up to 4 ata channels. For each channel the two base io addresses and the irq must be specified.
          ata0 and ata1 are enabled by default, with the values shown below.

ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
      ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
      ata2: enabled=1, ioaddr1=0x1e8, ioaddr2=0x3e0, irq=11
      ata3: enabled=1, ioaddr1=0x168, ioaddr2=0x360, irq=9

      ata[0-3]-master: or ata[0-3]-slave:

      This defines the type and characteristics of all attached ata devices:
      type=       type of attached device [disk|cdrom]
      path=       path of the image
      mode=       image mode [flat|concat|external|dll|sparse|vmware3|undoable|growing|volatile], only valid for disks
      cylinders=  only valid for disks
      heads=      only valid for disks
      spt=        only valid for disks
      status=     only valid for cdroms [inserted|ejected]
      biosdetect= type of biosdetection [none|auto], only for disks on ata0 [cmos]
      translation=type of translation of the bios, only for disks [none|lba|large|rechs|auto]
      model=      string returned by identify device command
      journal=    optional filename of the redolog for undoable and volatile disks

      Point  this  at a hard disk image file, cdrom iso file, or a physical cdrom device.  To create a hard disk image, try
      running bximage.  It will help you choose the size and then suggest a line that works with it.

      In UNIX it is possible to use a raw device as a Bochs hard disk, but WE DON'T RECOMMEND IT.

      The path is mandatory for hard disks. Disk geometry autodetection works with images created by bximage if CHS is  set
      to  0/0/0  (cylinders are calculated using  heads=16 and spt=63). For other hard disk images and modes the cylinders,
          heads, and spt are mandatory. In all cases the disk size reported from the image must be exactly C*H*S*512.

              The mode option defines how the disk image is handled. Disks can be defined as:
              - flat : one file flat layout
              - concat : multiple files layout
              - external : developer's specific, through a C++ class
              - dll : developer's specific, through a DLL
              - sparse : stackable, commitable, rollbackable
              - vmware3 : vmware3 disk support
              - undoable : flat file with commitable redolog
              - growing : growing file
              - volatile : flat file with volatile redolog

              The disk translation scheme (implemented in legacy int13 bios functions, and used by older operating systems like MS-
                      DOS), can be defined as:
              - none : no translation, for disks up to 528MB (1032192 sectors)
              - large : a standard bitshift algorithm, for disks up to 4.2GB (8257536 sectors)
              -  rechs  :  a revised bitshift algorithm, using a 15 heads fake physical geometry, for disks up to 7.9GB (15482880
                      sectors). (don't use this unless you understand what you're doing)
              - lba : a standard lba-assisted algorithm, for disks up to 8.4GB (16450560 sectors)
              - auto : autoselection of best translation scheme. (it should be changed if system does not boot)

              Default values are:
              mode=flat, biosdetect=auto, translation=auto, model="Generic 1234"

              The biosdetect option has currently no effect on the bios

              ata0-master: type=disk, path=10M.sample, cylinders=306, heads=4, spt=17
              ata0-slave:  type=disk, path=20M.sample, cylinders=615, heads=4, spt=17
              ata1-master: type=disk, path=30M.sample, cylinders=615, heads=6, spt=17
              ata1-slave:  type=disk, path=46M.sample, cylinders=940, heads=6, spt=17
              ata2-master: type=disk, path=62M.sample, cylinders=940, heads=8, spt=17
              ata2-slave:  type=disk, path=112M.sample, cylinders=900, heads=15, spt=17
              ata3-master: type=disk, path=483M.sample, cylinders=1024, heads=15, spt=63
              ata3-slave:  type=cdrom, path=iso.sample, status=inserted


ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
ata0-master: type=disk, path=diskc.img, cylinders=40, heads=8, spt=64






In this project you will write code to parse an executable file in ELF format and pass the result of the parsing to a program laoder we provide.

Required Reading

This project will require you to understand the ELF executable format.You will need to read the ELF Executable Format <> documentation. In this project, you will need to be able to parse the ELF program headers in order to find out how to load an executable file’s text (code) and data into process memory.

Project Synopsis

This project will require you to change the src/geekos/elf.c. Your only task is to implement the Parse ELF Executable() function. This involves reading the program headers of an ELF executable to find the file offset, length, and user address for the executable’s text and data segments. Based on this information,you should fill in the Exe Format data structure passed as a parameter. This data structure will be used by the loader to determine how to load the executable. The loader is already implemented for you.

Loading the Executable

GeekOS, like other operating systems, uses files to store executable programs. These files are in ELF format.We have provided you with a simple read-only filesystem for this project, plus a test file that you will load.The test file is src/user/a.c, and after compilation and building, GeekOS will see it as /c/a.exe. When GeekOS boots up, it reads /c/a.exe into memory, calls your parsing code from Parse ELF Executable() and starts a kernel-mode thread that will run the a.exe code. Loading ELF executables is fairly straightforward. You will need to locate the ELF program headers.These headers will describe the executable’s text and data segments. 1 As you parse the ELF executable, you will fill in the fields of an Exe Format data structure, which is a high level representation of how to load data from the executable file into memory.

Testing Your Project

If you’ve done everthying correctly, when you start Bochs you should see this output:

Hi ! This is the first string
Hi ! This is the second string
Hi ! This is the third (and last) string
If you see this you’re happy



     * From the data of an ELF executable, determine how its segments
     * need to be loaded into memory.
     * @param exeFileData buffer containing the executable file
     * @param exeFileLength length of the executable file in bytes
     * @param exeFormat structure describing the executable's segments
     *   and entry address; to be filled in
     * @return 0 if successful, < 0 on error
    int Parse_ELF_Executable(char *exeFileData, ulong_t exeFileLength,
            struct Exe_Format *exeFormat)
        TODO("Parse an ELF executable image");

其中exeFileData是指向a.exe内容开头的指针,exeFileLength是该文件的长度,exeFormat则为指向结构体struct Exe_Format的指针。 结构体struct Exe_Format的定义在elf.h中可以看到:

    struct Exe_Format {
        struct Exe_Segment segmentList[EXE_MAX_SEGMENTS]; /* Definition of segments */
        int numSegments;        /* Number of segments contained in the executable */
        ulong_t entryAddr;      /* Code entry point address */

包含了对需要载入内存的块的定义、包含于可执行文件的块的个数和接口指针的地址。 结构体struct Exe_Segment的定义:

     * A segment of an executable.
     * It specifies a region of the executable file to be loaded
     * into memory.
    struct Exe_Segment {
        ulong_t offsetInFile;    /* Offset of segment in executable file */
        ulong_t lengthInFile;    /* Length of segment data in executable file */
        ulong_t startAddress;    /* Start address of segment in user memory */
        ulong_t sizeInMemory;    /* Size of segment in memory */
        int protFlags;       /* VM protection flags; combination of VM_READ,VM_WRITE,VM_EXEC */

包含块的偏移量、长度、内存起始地址、在内存中所占大小以及一个标志量(其实就是文件的属性,可读、可写、可执行)。 直接看定义,和unix/Linux是一样的:

     * Bits in flags field of programHeader.
     * These describe memory permissions required by the segment.
    #define PF_R    0x4  /* Pages of segment are readable. */
    #define PF_W    0x2  /* Pages of segment are writable. */
    #define PF_X    0x1  /* Pages of segment are executable. */

关于如何加载elf的信息可以参考这里 再看两个结构体:

     * ELF header at the beginning of the executable.
    typedef struct {
        unsigned  char  ident[16];
        unsigned  short type;
        unsigned  short machine;
        unsigned  int   version;
        unsigned  int   entry;
        unsigned  int   phoff;
        unsigned  int   sphoff;
        unsigned  int   flags;
        unsigned  short ehsize;
        unsigned  short phentsize;
        unsigned  short phnum;
        unsigned  short shentsize;
        unsigned  short shnum;
        unsigned  short shstrndx;
    } elfHeader;

     * An entry in the ELF program header table.
     * This describes a single segment of the executable.
    typedef struct {
        unsigned  int   type;
        unsigned  int   offset;
        unsigned  int   vaddr;
        unsigned  int   paddr;
        unsigned  int   fileSize;
        unsigned  int   memSize;
        unsigned  int   flags;
        unsigned  int   alignment;
    } programHeader;


readelf -h a.exe


    ELF Header:
        Magic:   7f 45 4c 46 01 01 01 00 00 00 00 00 00 00 00 00
        Class:                             ELF32
        Data:                              2's complement, little endian
        Version:                           1 (current)
        OS/ABI:                            UNIX - System V
        ABI Version:                       0
        Type:                              EXEC (Executable file)
        Machine:                           Intel 80386
        Version:                           0x1
        Entry point address:               0x1000
        Start of program headers:          52 (bytes into file)
        Start of section headers:          4412 (bytes into file)
        Flags:                             0x0
        Size of this header:               52 (bytes)
        Size of program headers:           32 (bytes)
        Number of program headers:         3
        Size of section headers:           40 (bytes)
        Number of section headers:         7
        Section header string table index: 4
$ readelf -l a.exe


    Program Headers:
        Type           Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg Align
        LOAD           0x001000 0x00001000 0x00001000 0x000a2 0x000a2 R E 0x1000
        LOAD           0x0010c0 0x000020c0 0x000020c0 0x00028 0x00028 RW  0x1000
        GNU_STACK      0x000000 0x00000000 0x00000000 0x00000 0x00000 RW  0x4


现在就可以开始填代码了! 最终的Parse_ELF_Executable():

     * From the data of an ELF executable, determine how its segments
     * need to be loaded into memory.
     * @param exeFileData buffer containing the executable file
     * @param exeFileLength length of the executable file in bytes
     * @param exeFormat structure describing the executable's segments
     *   and entry address; to be filled in
     * @return 0 if successful, < 0 on error
    int Parse_ELF_Executable(char *exeFileData, ulong_t exeFileLength,
            struct Exe_Format *exeFormat)
        //TODO("Parse an ELF executable image");
        int i;
        elfHeader *ehdr = (elfHeader *) exeFileData;
        programHeader *phdr = (programHeader *) (exeFileData + ehdr->phoff);
        struct Exe_Segment *segment = exeFormat->segmentList;
        for (i = 0; i < 3; i++) {
            segment->offsetInFile = phdr->offset;
            segment->lengthInFile = phdr->fileSize;
            segment->startAddress = phdr->vaddr;
            segment->sizeInMemory = phdr->memSize;
         * of cource, you can assign one by one, you can see Program Headers
         * by "$ readelf -l exeFile"

        exeFormat->numSegments = 3;
        exeFormat->entryAddr = 0x1000;
        return 0;


  • 无匹配

登录 *

loading captcha image...
or Ctrl+Enter