Ⅰ. 실행 가능한 C코드 커널 생성 방법

• 목표: C소스 코드 파일을 추가하고, 이를 빌드하여 보호 모드 커널 이미지에 통합하는 것
  • C언어로 작성한 커널을 보호 모드 엔트리 포인트 뒷부분에 연결하고 엔트리 포인트에서는 C커널의 시작부분으로 이동하하면 된다.

1. 빌드 조건과 제약 사항

• 엔트리 포인트가 C코드를 실행하려면, 적어도 3가지 제약조건을 만족해야한다.

  ① C라이브러리를 사용하지 않게 빌드해야 한다.

  • 부팅된 후, 보호 모드 커널이 실행되면 C라이브러리가 없으므로 라이브러리에 포함된 함수를 호출할 수 없다.
  • 커널은 자신을 실행하기 위한 최소한의 환경만 설정하므로, 작성된 커널 코드만 사용하도록 빌드해야 한다.

  ② 0x10200 위치에서 실행하게 빌드해야 한다.

  • 0x10000의 위치에 이전에 작성했던 한 섹터 크기의 보호 모드 엔트리 포인트가 존재하며, 결합된 C코드는 512byte이후인 0x10200의 위치부터 로딩된다.
  • 해당 위치의 코드는 C 코드 중 가장 먼저 실행되어야 하는 함수(엔트리 포인트)가 위치해야 한다.
  • 커널이 실행되는 어드레스가 중요한 이유는 선형 주소를 참조하게 생성된 코드나 데이터 때문이다.
    • C언어에서 전역 변수의 어드레스나 함수의 어드레스를 참조하는 경우 실제로 존재하는 선형 주소로 변환된다.
    • 따라서, 메모리에 로딩되는 어드레스가 변한다면, 이러한 값들도 변경해줘야 정상적으로 동작한다.

  ③ 코드나 데이터 외에 기타 정보를 포함하지 않는 바이너리 파일 형태여야 한다.

  • GCC를 통해, 실행 파일을 생성하면 ELF 또는 PE 파일 포맷과 같은 특정 OS에서 실행할 수 있는 포맷으로 생성된다.
    • 해당 포맷들은 필요한 코드와 데이터 정보 외의 불필요한 정보를 포함한다.
    • 해당 파일 포맷을 그대로 사용하게 되면 엔트리 포인트에서 파일 포맷을 해석하여 해당 정보에 따라 처리하는 기능이 포함되야 하므로 코드가 복잡해진다.
  • 코드와 데이터만 포함된 바이너리 형태를 사용한다면, 엔트리 포인트에서 해당 어드레스로 점프(jmp)하는 것만으로 C코드를 실행할 수 있다.

2. 소스 파일 컴파일

  (라이브러리를 사용하지 않고 오브젝트 파일 생성 방법)

• gcc를 이용하여, C코드를 컴파일 할 경우 -c 옵션을 사용하면 된다.
• 라이브러리를 사용하지 않고 오브젝트를 생성하려면, gcc의 -ffreestanding 을 사용하면 된다.

# main.c파일을 라이브러리를 사용하지 않는 main.o로 컴파일 하는 방법
# -m32는 32bit 코드 생성을 위해 설정한 옵션이다.

$ gcc -c -m32 -ffreestanding main.c

3. 오브젝트 파일 링크

 (라이브러리를 사용하지 않고, 특정 어드레스에서 실행 가능한 커널 이미지 파일 생성 방법)

(1) 개요

• 실행 파일을 구성하는 섹션의 배치와 로딩될 어드레스, 코드 내에서 가장 먼저 실행된 코드인 엔트리 포인트를 지정해줘야 한다.
  • 섹션의 배치하는 방식과 크기 정렬 방식에 따라서 OS의 메모리 구조와 크기가 달라진다.
• 섹션 배치를 다시하는 이유
  • 실행 파일이 링크될 때, 코드나 데이터 이외의 디버깅 관련 정보와 심볼 정보 등이 포함되기 때문이다.
  • 해당 정보들은 커널을 실행하는데, 직접적인 관련이 없으므로 최종 바이너리 파일을 생성할 때 이를 제거하려고 섹션을 재배치 하는 것이다.
  • 코드와 데이터를 실행 파일 앞쪽으로 이동시키면, 손쉽게 나머지 부분을 제거할 수 있다.

(2) 섹션 배치와 링커 스크립트, 라이브러리를 사용하지 않는 링크

• Section

  • 실행 파일 또는 오브젝트 파일에 존재하며, 공통된 속성(코드, 데이터, 각종 심볼, 디버깅 정보 등)을 담는 영역이다.

  • 무순히 많은 섹션이 있지만, 핵심 역할을 하는 섹션은 3가지가 존재한다.

    ① .text 섹션

    • 실행 가능한 코드가 존재한다.
    • 프로그램이 실행되면, 코드를 수정할 일이 거의 없으므로 읽기 전용 (Read-Only) 속성을 갖고 있다.

    ② .data 섹션

    • 초기화된 데이터가 존재하며, 보통 전역변수 혹은 0이 아닌 값으로 초기화된 정적 변수가 포함된다.
    • 데이터를 저장하는 섹션이기 때문에 일반적으로 읽기/쓰기 속성을 갖는다.

    ③ .bss 섹션

    • 초기화되지 않는 데이터가 존재한다.
    • 해당 섹션은 0으로 초기화될 뿐, 실제 데이터가 없으므로 실행 파일이나 오브젝트 파일 상에는 별도의 영역을 차지하지 않는다.
    • but, 메모리에 로딩되었을 때 코드는 해당 영역 변수들의 초기값을 0으로 가정한다. 따라서, 정상적으로 프로그램을 실행하려면 메모리 로딩할 때, 해당 섹션 영역을 모두 0으로 초기화 해야 한다.

• 소스 코드를 컴파일하여, 생성한 오브젝트 파일은 각 섹션의 크기와 파일 내에 있는 오프셋 정보가 존재한다.

  • 오브젝트 파일은 중간 단계의 생성물로, 다른 오브젝트 파일과 합쳐지기 때문이며, 합쳐지는 순서에 따라 섹션의 어드레스는 얼마든지 바뀔 수 있다.

• 오브젝트 파일을 결합하여 정리하고 실제 메모리에 로딩될 위치를 결정하는 것이 “링커”이다.

  • 링커의 주된 역할은 오브젝트 파일을 모아 섹션을 통합하고 그에 따라 어드레스를 조정하며 외부 라이브러리에 있는 함수와 연결해준다.
  • 링커가 실행파일을 만드려면, 파일 구성에 대한 정보가 필요하다. 이때 사용하는 것이 ‘링커 스크립트(Linker Script)’이다.

• 링커 스크립트

  • 각 섹션의 배치 순서와 시작 어드레스, 섹션 크기 정렬 등의 정보를 저장해 놓은 텍스트이다. (Ref: http://sourceware.org/binutils/docs/ld )

  • 링커 스크립트의 기본 형식

    SECTIONS{
    		SectionName Load Address :  ;섹션 이름과 메모리에 로드할 어드레스
    		{
    				*(.text)                ;오브젝트 파일의 섹션 중에 SectionName에 통합할 섹션 이름
    				 ``` 생략 ```
             . = AㅋLIGN (AlignValue) ;현재 어드레스를 Align Value에 맞추어 이동, 다음 섹션의 시작은 AlignValue의 배
    		} = 0x00000000              ;섹션을 채울 기본값
    
    		``` 생략 ```
    }
    

• 실습

  • 32bit 링커 스크립트 파일 (/usr/lib/x86_64-linux-gnu/ldscripts/elf_i386.x)을 1.Kernel32\\elf_i386.x에 저장하여 재배치 작업을 준비한다.

  • 섹션 재배치는 텍스트나 데이터와 관계없는 섹션(.tdata, .tbss, .ctors, .got 등)의 기본 구조 즉, ‘SectionName{…}’ 부분 전체를 코드 및 데이터 섹션의 뒷부분으로 이동하거나 코드 및 데이터에 관련된 섹션(.text, .data, .bss, .rodat)을 가장 앞으로 이동함으로써 처리할 수 있다.

    • 본 실습에서는 필요한 섹션을 링커 스크립트의 가장 앞쪽으로 이동시켜 처리하였다.

  • 섹션 크기 정렬 부분은 ALIGN()부분의 값을 수정함으로써 변경할 수 있다.

    • 크기 정렬 값은 임의의 값으로 설정해도 되지만, 편의상 데이터 섹션의 시작을 섹터 크기(512byte)에 맞추었다.
    • 이후, 커널 공간이 부족하다면 해당 값을 더 작게 함으로써 보호 모드 커널이 차지하는 비중을 줄일 수 있다.

    /* Default linker script, for normal executables */
    
    OUTPUT_FORMAT("elf32-i386", "elf32-i386",
    	      "elf32-i386")
    OUTPUT_ARCH(i386)
    ENTRY(_start)
    SEARCH_DIR("=/usr/local/lib/i386-linux-gnu"); SEARCH_DIR("=/lib/i386-linux-gnu"); SEARCH_DIR("=/usr/lib/i386-linux-gnu"); SEARCH_DIR("=/usr/lib/x86_64-linux-gnu32"); SEARCH_DIR("=/usr/local/lib32"); SEARCH_DIR("=/lib32"); SEARCH_DIR("=/usr/lib32"); SEARCH_DIR("=/usr/lib/x86_64-linux-gnu"); SEARCH_DIR("=/usr/local/lib"); SEARCH_DIR("=/lib"); SEARCH_DIR("=/usr/lib"); SEARCH_DIR("=/usr/i386-linux-gnu/lib32"); SEARCH_DIR("=/usr/x86_64-linux-gnu/lib32"); SEARCH_DIR("=/usr/i386-linux-gnu/lib");
    SECTIONS
    {
      /* Read-only sections, merged into text segment: */
      PROVIDE (__executable_start = SEGMENT_START("text-segment", 0x08048000)); . = SEGMENT_START("text-segment", 0x08048000) + SIZEOF_HEADERS;
    
      /*******************************************************************/
      /* 섹션 재배치로 인해 앞부분으로 이동된 부분 */
      .text 0x10200          :
      {
        *(.text .stub .text.* .gnu.linkonce.t.*)
        /* .gnu.warning sections are handled specially by elf32.em.  */
        *(.gnu.warning)
      } =0x90909090
    
      .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
      .rodata1        : { *(.rodata1) }
      
      /* 데이터 영역의 시작을 섹터 단위로 맞춤 */
      . = ALIGN (512);
    
      .data           :
      {
        *(.data .data.* .gnu.linkonce.d.*)
        SORT(CONSTRUCTORS)
      }
      .data1          : { *(.data1) }
    
      __bss_start = .;
      .bss            :
      {
       *(.dynbss)
       *(.bss .bss.* .gnu.linkonce.b.*)
       *(COMMON)
       /* Align here to ensure that the .bss section occupies space up to
          _end.  Align after .bss to ensure correct alignment even if the
          .bss section disappears because there are no input sections.
          FIXME: Why do we need it? When there is no .bss section, we don't
          pad the .data section.  */
       . = ALIGN(. != 0 ? 32 / 8 : 1);
      }
      . = ALIGN(32 / 8);
      . = ALIGN(32 / 8);
      _end = .; PROVIDE (end = .);
    /*********************************************************************************/
    
      .interp         : { *(.interp) }
      .note.gnu.build-id : { *(.note.gnu.build-id) }
      .hash           : { *(.hash) }
      .gnu.hash       : { *(.gnu.hash) }
      .dynsym         : { *(.dynsym) }
      .dynstr         : { *(.dynstr) }
      .gnu.version    : { *(.gnu.version) }
      .gnu.version_d  : { *(.gnu.version_d) }
      .gnu.version_r  : { *(.gnu.version_r) }
      .rel.init       : { *(.rel.init) }
      .rel.text       : { *(.rel.text .rel.text.* .rel.gnu.linkonce.t.*) }
      .rel.fini       : { *(.rel.fini) }
      .rel.rodata     : { *(.rel.rodata .rel.rodata.* .rel.gnu.linkonce.r.*) }
      .rel.data.rel.ro   : { *(.rel.data.rel.ro .rel.data.rel.ro.* .rel.gnu.linkonce.d.rel.ro.*) }
      .rel.data       : { *(.rel.data .rel.data.* .rel.gnu.linkonce.d.*) }
      .rel.tdata	  : { *(.rel.tdata .rel.tdata.* .rel.gnu.linkonce.td.*) }
      .rel.tbss	  : { *(.rel.tbss .rel.tbss.* .rel.gnu.linkonce.tb.*) }
      .rel.ctors      : { *(.rel.ctors) }
      .rel.dtors      : { *(.rel.dtors) }
      .rel.got        : { *(.rel.got) }
      .rel.bss        : { *(.rel.bss .rel.bss.* .rel.gnu.linkonce.b.*) }
      .rel.ifunc      : { *(.rel.ifunc) }
      .rel.plt        :
        {
          *(.rel.plt)
          PROVIDE_HIDDEN (__rel_iplt_start = .);
          *(.rel.iplt)
          PROVIDE_HIDDEN (__rel_iplt_end = .);
        }
      .init           :
      {
        KEEP (*(SORT_NONE(.init)))
      }
      .plt            : { *(.plt) *(.iplt) }
    .plt.got        : { *(.plt.got) }
    .plt.sec        : { *(.plt.sec) }
      .text           :
      {
        *(.text.unlikely .text.*_unlikely .text.unlikely.*)
        *(.text.exit .text.exit.*)
        *(.text.startup .text.startup.*)
        *(.text.hot .text.hot.*)
        *(.text .stub .text.* .gnu.linkonce.t.*)
        /* .gnu.warning sections are handled specially by elf32.em.  */
        *(.gnu.warning)
      }
      .fini           :
      {
        KEEP (*(SORT_NONE(.fini)))
      }
      PROVIDE (__etext = .);
      PROVIDE (_etext = .);
      PROVIDE (etext = .);
      .rodata         : { *(.rodata .rodata.* .gnu.linkonce.r.*) }
      .rodata1        : { *(.rodata1) }
      .eh_frame_hdr : { *(.eh_frame_hdr) *(.eh_frame_entry .eh_frame_entry.*) }
      .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) *(.eh_frame.*) }
      .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table
      .gcc_except_table.*) }
      .gnu_extab   : ONLY_IF_RO { *(.gnu_extab*) }
      /* These sections are generated by the Sun/Oracle C++ compiler.  */
      .exception_ranges   : ONLY_IF_RO { *(.exception_ranges
      .exception_ranges*) }
      /* Adjust the address for the data segment.  We want to adjust up to
         the same address within the page on the next page up.  */
      . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
      /* Exception handling  */
      .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) *(.eh_frame.*) }
      .gnu_extab      : ONLY_IF_RW { *(.gnu_extab) }
      .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
      .exception_ranges   : ONLY_IF_RW { *(.exception_ranges .exception_ranges*) }
      /* Thread Local Storage sections  */
      .tdata	  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
      .tbss		  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
      .preinit_array     :
      {
        PROVIDE_HIDDEN (__preinit_array_start = .);
        KEEP (*(.preinit_array))
        PROVIDE_HIDDEN (__preinit_array_end = .);
      }
      .init_array     :
      {
        PROVIDE_HIDDEN (__init_array_start = .);
        KEEP (*(SORT_BY_INIT_PRIORITY(.init_array.*) SORT_BY_INIT_PRIORITY(.ctors.*)))
        KEEP (*(.init_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .ctors))
        PROVIDE_HIDDEN (__init_array_end = .);
      }
      .fini_array     :
      {
        PROVIDE_HIDDEN (__fini_array_start = .);
        KEEP (*(SORT_BY_INIT_PRIORITY(.fini_array.*) SORT_BY_INIT_PRIORITY(.dtors.*)))
        KEEP (*(.fini_array EXCLUDE_FILE (*crtbegin.o *crtbegin?.o *crtend.o *crtend?.o ) .dtors))
        PROVIDE_HIDDEN (__fini_array_end = .);
      }
      /*********************************************************************************/
      /* 섹션 재배치로 인해 이동된 부분 */
      _edata = .; PROVIDE (edata = .);
    
      /* Thread Local Storage sections  */
      .tdata	  : { *(.tdata .tdata.* .gnu.linkonce.td.*) }
      .tbss		  : { *(.tbss .tbss.* .gnu.linkonce.tb.*) *(.tcommon) }
      /*********************************************************************************/
      .ctors          :
      {
        /* gcc uses crtbegin.o to find the start of
           the constructors, so we make sure it is
           first.  Because this is a wildcard, it
           doesn't matter if the user does not
           actually link against crtbegin.o; the
           linker won't look for a file to match a
           wildcard.  The wildcard also means that it
           doesn't matter which directory crtbegin.o
           is in.  */
        KEEP (*crtbegin.o(.ctors))
        KEEP (*crtbegin?.o(.ctors))
        /* We don't want to include the .ctor section from
           the crtend.o file until after the sorted ctors.
           The .ctor section from the crtend file contains the
           end of ctors marker and it must be last */
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .ctors))
        KEEP (*(SORT(.ctors.*)))
        KEEP (*(.ctors))
      }
      .dtors          :
      {
        KEEP (*crtbegin.o(.dtors))
        KEEP (*crtbegin?.o(.dtors))
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o ) .dtors))
        KEEP (*(SORT(.dtors.*)))
        KEEP (*(.dtors))
      }
      .jcr            : { KEEP (*(.jcr)) }
      .data.rel.ro : { *(.data.rel.ro.local* .gnu.linkonce.d.rel.ro.local.*) *(.data.rel.ro .data.rel.ro.* .gnu.linkonce.d.rel.ro.*) }
      .dynamic        : { *(.dynamic) }
      .got            : { *(.got) *(.igot) }
      . = DATA_SEGMENT_RELRO_END (SIZEOF (.got.plt) >= 12 ? 12 : 0, .);
      .got.plt        : { *(.got.plt)  *(.igot.plt) }
      
      /*********************************************************************************/
      /* 섹션 재배치로 인해 이동된 부분 */
      .eh_frame_hdr : { *(.eh_frame_hdr) }
      .eh_frame       : ONLY_IF_RO { KEEP (*(.eh_frame)) }
      /* Exception handling  */
      .gcc_except_table   : ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
      .eh_frame       : ONLY_IF_RW { KEEP (*(.eh_frame)) }
      .gcc_except_table   : ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }  
      /*********************************************************************************/    
    
      /* Stabs debugging sections.  */
      .stab          0 : { *(.stab) }
      .stabstr       0 : { *(.stabstr) }
      .stab.excl     0 : { *(.stab.excl) }
      .stab.exclstr  0 : { *(.stab.exclstr) }
      .stab.index    0 : { *(.stab.index) }
      .stab.indexstr 0 : { *(.stab.indexstr) }
      .comment       0 : { *(.comment) }
      /* DWARF debug sections.
         Symbols in the DWARF debugging sections are relative to the beginning
         of the section so we begin them at 0.  */
      /* DWARF 1 */
      .debug          0 : { *(.debug) }
      .line           0 : { *(.line) }
      /* GNU DWARF 1 extensions */
      .debug_srcinfo  0 : { *(.debug_srcinfo) }
      .debug_sfnames  0 : { *(.debug_sfnames) }
      /* DWARF 1.1 and DWARF 2 */
      .debug_aranges  0 : { *(.debug_aranges) }
      .debug_pubnames 0 : { *(.debug_pubnames) }
      /* DWARF 2 */
      .debug_info     0 : { *(.debug_info .gnu.linkonce.wi.*) }
      .debug_abbrev   0 : { *(.debug_abbrev) }
      .debug_line     0 : { *(.debug_line .debug_line.* .debug_line_end ) }
      .debug_frame    0 : { *(.debug_frame) }
      .debug_str      0 : { *(.debug_str) }
      .debug_loc      0 : { *(.debug_loc) }
      .debug_macinfo  0 : { *(.debug_macinfo) }
      /* SGI/MIPS DWARF 2 extensions */
      .debug_weaknames 0 : { *(.debug_weaknames) }
      .debug_funcnames 0 : { *(.debug_funcnames) }
      .debug_typenames 0 : { *(.debug_typenames) }
      .debug_varnames  0 : { *(.debug_varnames) }
      /* DWARF 3 */
      .debug_pubtypes 0 : { *(.debug_pubtypes) }
      .debug_ranges   0 : { *(.debug_ranges) }
      /* DWARF Extension.  */
      .debug_macro    0 : { *(.debug_macro) }
      .debug_addr     0 : { *(.debug_addr) }
      .gnu.attributes 0 : { KEEP (*(.gnu.attributes)) }
      /DISCARD/ : { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
    }
    

  • 수정한 링커 스크립트를 이용하여, 라이브러리를 사용하지 않고 실행파일을 생성하는 방법

    /usr/mips-linux-gnu/bin/ld -melf_i386 -T elf_i386.x -nostdlib main.o -o main.elf