많은 시간을 이것저것 미리 살펴 보느라 오래 걸렸다. 처음에 너무 대책 없이 시작하다 보니 이것저것 삐걱거리고 다시 학습해야 할 내용들이 많아서 당분간 쉬었다(라고 쓰고… 그냥 귀찮아서 놀았다…) 음.. 기존 내 BaramOS(바람OS)는  부트로더 에서 커널로더를 거친 후 커널로 진입하는 방식으로 구현되어 있다. VC2010에서 커널을 만들다 보니 부트로더에서 바로 호출 할 수 없었다. 이유는 http://manggong.org/blog/64 에 간략하게 적은 내용대로 VC2010컴파일러가 32비트 컴파일러 이기 때문이다. (NASM의 obj 파일을 VC에서 링크를 할 수 없다라는게 이유. MASM으로 하면 된다는데… 것도 문제.. 흠..) 또 VC 컴파일러다 보니 PE 파일 포맷이다. (요것도 따로 배워야 한다… 메모리 재배치라나 뭐래나~~). 뭐 인터넷에 검색해 보니 부트로더에서 바로 커널 불러들이는 OS들도 있는 것 같지만..그냥 이대로 갈 생각이다.




리얼모드


부트로더, OS_LDR.SYS는 현재 16비트에서 동작한다. 요걸 달리 리얼 모드 라고 한다고 한다. 이름도 참… 리얼이 뭐냐!~~ 그럼 가상모드 도 있단 말이냐?? ㅋㅋ 헉… 검색해보니 가상모드 도 있다. 흠흠흠…. 여튼. 리얼모드는 리얼 주소 모드 또는 호환 모드 라고 하며, 80286이후의 x86호환 CPU 운영 방식이라고 위키백과 에서는 설명하고 있다. 뭔 소리냐??? 좀더 더 쉽게 풀어 달란 말이다. 흠… 검색하자… 리얼모드는 호환 모드라고 한다고 했다. 즉, 80286 이전에 CPU를 호환하기 위한 모드 라고 한다. 왜 호환 하는 거야?? 기존 만들어 놨던 소프트웨어 지원할라고??? 몰겠다. 다시 리얼모드로 돌어와서 리얼 모드라는 이놈은 1M 이상의 메모리를 접근 할 수 없단다. 왜??? 만들 당시 1M도 큰 메모리였단다.. ㅎㅎㅎ  1M이기 때문에 메모리에 액세스 할 주소는 20비트면 충분 했나 보다…(에효 좀더 크게 좀 잡아놓지…. 20비트가 뭐냐?? 계산하기 빡 세게…) 20비트로 주소를 계산했단다… 어떻게??? 세그먼트:오프셋 요렇게 말이다. 근데 세그먼트 크기는 16비트이다. 20비트에서 4비트 부족하다. 그래서 오프셋 이란 놈을 더 뒀다. 그러면 오프셋이 나머지 4비트일까??? 아니다. 요놈도 16비트다. 그럼 32비트 쓴다는거?? ㅋㅋ 그랬으면 얼마나 좋았을 까? 흠. 졸라 복잡한 계산식으로 20비트 만든단다. 졸라 어렵다. 세그먼트를 왼쪽으로 4비트 시프트 시키고 거기에다가 오프셋을 더해 준단다.  예를 들어.. 세그먼트 = 0x0700와 오프셋 0x0C00 라면 세그먼트 4비트 왼쪽 시프트해서 0x7000 만들고 여기에 0x0C00 더해 주는 방식이다.


  0 7 0 0 0
+   0 C 0 0
    7 C 0 0


이렇게 졸라 복잡한 계산식(?)으로 1M까지 메모리를 접근했다.


근데 내가 초딩 때 봤던 도스가 리얼모드에서 동작했다고 한다. 여기서 급 궁금증이 생겼다. 도스라면 640KB밖에 여유 메모리가 없었던 기억이 있다. 게임 하나 실행 할라 치면, 메모리 상주 프로그램 다 지워줘야 했다. 1M라며????


1MB안에서 다시 요놈 저놈이 쓸 메모리 공간 다 주고 640KB가 남은 거란다. 640KB도 크게 느껴졌다고 하니~^^ ㅋㅋㅋ


0x00000000 - 0x0009FFFF   RAM
  0x00000000 - 0x000003FF 리얼모드용 인터럽트 벡터
  0x00000300 - 0x000003FF BIOS DATA 영역
  0x00000400 - 0x000004FF BIOS가 사용하는 영역
  0x00000500 - 0x00007BFF 임시영역? ( 자유 영역, 도스 파라미터 영역)
  0x00007C00 - 0x00007DFF 부트 영역
  0x00008000 – 0x0009FBFF 자유영역
  0x00080000 – 0x0009FBFF 자유영역
  0x0009FC00 - 0x0009FFFF 확장 BIOS DATA영역
0x000A0000 – 0x000BFFFF   비디오 카드 접근 영역
  0x000A0000 - 0x000AFFFF 그래픽 모드 비디오 메모리
  0x000B0000 – 0x000BFFFF 흑백 테스트 모드 비디오 메모리
  0x000B8000 –0x000BC000 컬러 텍스트 모드 비디오 메모리
0x000C0000 - 0x000C7FFF   비디오 BIOS
0x000C8000 – 0x000EFFFF   각종 카드의 ROM 영역
0x000F0000 – 0x000FFFFF   메인보드 BIOS

(출처 : http://wiki.osdev.org/Memory_Map_(x86))


요기 위 처럼 1M를 이넘 저넘 예약 되어 있다. 휴~ 리얼모드에서 플밍 하기 참~ 힘들었겠다는 생각이 단다. 뭐~ 힘들게 만든 프로그램 컴퓨터에서 실행시키기도 힘들었다. 무슨 설정을 그리 해야 했는지..




보호모드


80286 맹글면서 메모리 버스를 24bit로 늘렸단다. 뭔 말이냐면 메모리를 24bit 만큼 쓸 수 있다는 것이다. 16M인데?? (참~~~ 많기도 하다..ㅋ ) ㅎㅎ 80386에서는 요게 32bit로 늘렸단다. 그래 드뎌 4GB 메모리가 참조 가능해진다. 뭐, 요즘 요것도 적은 편이지만… 64비트가 나온판에 ㅋㅋㅋ 여튼. 보호모드에서는 세그먼트 레지스터를 세그먼트 셀렉터(selector)라는 이름으로 바꾸었단다. 왜 바꾸냐?? 머리 아프게 시리.. 세그먼트 레지스터는 물리 주소 자체를 가르키는 역활을 했으나 보호모드에서는 세그먼트 셀렉터 이놈은 주소 공간을 가르키는 게 아니고 디스크립터 테이블의 디스크립터 이라는 놈 자체를 가르킨다고 한다. 그럼 디스크립터 테이블 이놈이 무엇이냐?? 8바이트로 구성된 코드 세그먼트 디스크립터, 데이터 세그먼트 디스크립터 등등의 세그먼트 디스크립터를 모아 놓은게 디스크립터 테이블이란다. 이 중 한놈을 세그먼트 셀렉터 라는 놈이 가르킨단다. 딱 보니, 디스크립터 구조체 배열의 인덱스 번호를 세그먼트 셀렉터가 가르키는 꼴이다. 흠..디스크립터 구조는 다음과 같다.

 

겁나 복잡하게 생겼다. 저 Base Address 주소 가르키는 구조좀 봐라 … 아주 조각을 내놨다. 얼씨구 Segment Limit도 조각 냈네.. 요거 설계 하는 사람이 머리에 스팀 좀 받았겠다… 그러니 요거 배우는 나는 더 스팀 받을 수 밖에…ㅋㅋㅋㅋ 여튼 우습다. 흠.. 각 설명은 요렇다는 데..

  • Base Address : 세그먼트의 시작 주소를 가르킨다. 32비트 크기이므로 0~4GB까지 가능하다.
  • Segment Limit : 세그먼트의 크기를 나타낸다. 20비트의 크기로 0~1MB까지 가능하다. G 비트가 1로 설정되면 4KB를 여기에다 곱해준단다. 그럴 경우 0~4GB까지 설정 가능하단다.
  • Type : 4비트 크기로 세그먼트의 타입을 지정한단다. 코드 또는 데이터 로 말이다. 근데 여기에 읽기 쓰기 권한을 비트로 준단다. (엠병)
    0bit 1bit 2bit 3bit Type 설명
    0 0 0 0 0 데이터 데이터 세그먼트 읽기 전용
    1 0 0 0 1 데이터 데이터 세그먼트 읽고/ 접근 여부 (접근 여부 : 디스크립터가 참조 될 때 1로 설정함)
    2 0 0 1 0 데이터 데이터 세그먼트 읽고/쓰기
    3 0 0 1 1 데이터 데이터 세그먼트 읽고/쓰기/접근 여부
    4 0 1 0 0 데이터 데이터 세그먼트 읽기 전용/역방향 (역방향: 스택처럼 상위 주소에서 하위 주소로 자라남)
    5 0 1 0 1 데이터 데이터 세그먼트 읽기 전용/역방향/접근여부
    6 0 1 1 0 데이터 데이터 세그먼트 읽고/쓰기/역방향
    7 0 1 1 1 데이터 데이터 세그먼트 읽고/쓰기/역방향/접근 여부
    8 1 0 0 0 코드 코드 세그먼트 실행 전용
    9 1 0 0 1 코드 코드 세그먼트 실행전용/접근 여부
    A 1 0 1 0 코드 코드 세그먼트 실행/읽기
    B 1 0 1 1 코드 코드 세그먼트 실행/읽기/접근여부
    C 1 1 0 0 코드 코드 세그먼트 실행 전용/접근가능 (접근가능: (권한에 관계없이 모두 접근 가능)
    D 1 1 0 1 코드 코드 세그먼트 실행 전용/접근가능/접근 여부
    E 1 1 1 0 코드 코드 세그먼트 실행/읽기/접근 가능
    F 1 1 1 1 코드 코드 세그먼트 실행/읽기/접근 가능/접근여부
  • S : 디스크립터 타입을 가르키신단다. 0 일때는 시스템 디스크립터, 1일 때는 걍 디스크립터(코드, 데이터)
  • DPL : 2비트로 세그먼트 접근 권한(? 요건 또 뭐냐..) 을 주신단다. 주로 0은 커널, 3은 유저(?) 접근 가능 하단다.
  • P : 페이징과 관련 있단다.
  • AVL : 임의 용도란다.
  • L : 64비트 코드 세그먼트인지, 32비트인지를 의미한단다. 1: 64, 0:32비트 ..
  • D/B : 16비트용인지 32비트용인지를 의미한단다. 1: 32비트, 0: 16비트
  • G : Segment Limit에 4Kb를 곱할지 안 곱할지.


빡시다… 겁나 복잡(?) 하다. 뭐가 이리 복잡하게 해 놓은 건지 원… 여튼, 세그먼트 셀렉터는 이놈들 중 하나의 인덱스 번호를 가지고 있고 해당 디스크립터가 가리키는 메모리에 접근 한단다. 뭐, 메모리 조각조각 내서 사용하는 페이징은 사용하지 않으면 실제 물리 주소고 여기에 페이징을 사용한다면 그냥 가상 주소라고 한단다. 뭐 페이징은 아직까지 사용 할 생각 없으니, 물리 주소라고 봐도 무관하겠다.


흠 근데 이런 디스크립터 테이블이 3종류나 있단다. 아놔!~~~~ 보호모드 겁나 짜증나는 놈이네…


GLOBAL DESCRIPTOR TABLE 이라는 GDT 라는 놈하고

LOCAL DESCRIPTOR TABLE 이라는 LDT 라는 놈하고

INTERRUPT DESCRIPTOR TABLE 이라는 IDT 테이블


 요렇게 3개 있단다. 그러면 왜 3개씩이나 있는 이유가 뭐냐??? 물리주소를 가르키는 얘라며~!!!!!!!!!!!!!!! 이런게 3개 있을 필요가 있냐고!!!!~~~휴~~ 진정해야지…


GDT : 전역 디스크립터 테이블이라고 하며 커널에서 사용하기 위해서 구성된다고 한다.
LDT : 지역 디스크립터 테이블이라고 하며 보통 어플리케이션 에서 사용하기 위해 구성된다고 한다.
IDT :  각 인터럽트를 사용하기 위해 구성된다고 한다.


GDT와 LDT 디스크립터 구성은 동일 한단다. (그래~~~)  위에 표기한 디스크립터 구조다.

IDT 구조는 다음과 같다.


  • 세그먼트 셀렉터(2바이트) : GDT 던 LDT 던 이 놈들이 가지고 있는 디스크립터 인덱스로 설정한다.
  • 오프셋(4바이트) : 디스크립터에 설정된 Base Address에서 + 오프셋 한 값.
  • P(1비트) : 디스크립터가 물리 메모리 영역인지 아닌지 여부를 나타내는 것 같은데 1로 설정하란다. 0은 사용안하거나 Paging 처리 할때.
  • DPL(2비트) : 특권 레벨이라는데 디스크립터의 DPL 처럼 접근권한. 즉 0은 커널, 3은 유저. 요것도 0.
  • S(1비트) : 요건 모르겠다. 그냥 0 .
  • Type(4비트) : Gate 타입을 입력.
    0101 0x5 5 80386 32bit Task Gate
    0110 0x6 6 80286 16bit Interrupt Gate
    0111 0x7 7 80286 16bit Trap Gate
    1110 0xE 14 80386 32bit Interrupt Gate
    1111 0xF 15 80386 32bit Trap Gate

    Interrupt Gate : 하드웨어 인터럽트를 위해 만들어 진 넘.
    Trap Gate : 소프트웨어 인터럽트나 Exception 처리하기 위해 만들어 진 넘
    Task Gate : Task Switching을 위해 만들어 진 넘.

IDT는 Interrupt vector table을 구현해 놓은 놈인데
- 소트트웨어 인터럽트
- 하드웨어 인터럽트
- 프로세서 Exception

의해 사용 된단다.


정리하믄 IDT는 GDT나 LDT에 있는 디스크립터가 가리키는 메모리 세그먼트에서 offset 만큼 위치의 함수를 호출하나 보다.

아흐… 겁나 머리 아프다. 뭐 이리 알아야 할게 많아~~~!!!!


흠…위에서 IDT에서 언급한 특권 레벨, 디스크립터의 접근 권한 요거에 대해서 더 살펴 봤더니 0,1,2,3 요렇게 권한등급이 있는데 0은 코널 수준이고 3은 유저(어플리케이션)에서 접근 할 수 있는 없는지를 나타내는 거란다. 보통 0과 3만 쓴다고 한다. 현재 불리우는 놈의 권한 기록은 세그먼트 셀렉터에 있다고 한다. 엥?? CS, DS, ES, FS 에???

세그먼트 셀렉터의 구조다. 보호모드로 바뀌면서 저렇게 구조를 나눠서 사용하나 보다. Index는 디스크립터 테이블에서 인덱스 값 이고 TI  요놈은 GDT(0) 테이블을 참조 할 것인가 LDT(1) 테이블을 참조 할 것인가 구분자이고 RPL 요놈이 접근하는 특권 레벨 을 가지고 있는 놈이란다. 요넘이 3인데 권한이 0인 놈을 접근 하면 CPU는 에러를 뱉어 낸다는군.

자!!~~~ 이제 또 뭘 알아야 하냐???




GDTR, LDTR, IDTR


흠… 힘들다..귀찮고…

보호 모드 진입을 하기 위해선, GDT는 이미 구성되어 있어야 한다고 한다… 메모리에 그냥 만들어 놓으면 되나??? 아니다. GDT를 읽는 레지스터가 있다고 한다. 이름하야 GDTR 이 레지스터에 GDT 테이블을 메모리 위치를 넘겨 주면 된다고 한다. 그럼 그냥 mov GDTR, [메모리 위치] 냐… 것도 아니다. lgdt 라는 어셈 명령어를 써서 넘겨야 한다. 또한 lgdt 명령어에 테이블 메모리 위치가 아니고 GDT의 총크기와 메모리 위치를 넘겨야 한단다.

struct
{
    unsigned short GDT_Size;
    unsigned int GDT_Address;
} GDT_INFO

lgdt GDT_INFO

요런 방식으로 명령을 주면 GDTR 레지스터에 GDT가 들어간다고 한다. 흠… 그래 그리고 ? 또… GDT 구성에 있어서 첫번째 인덱스는 NULL 이여야 한다고 한다. NULL??? 아무값도 없이 0으로 채워주면 된다고 한다. 사용되지 않는다는데 뭘…흠… 왜?? 모르겠다. 그냥 그래 라고 하니 그래야지. 하지만 또 성실하게 검색 질  해봤더니 “초기화 과정에서 사용되지 않은 레지스터를 통해 메모리에 접근하려는 시도를 막기 위함이다.” 라고 하네…뭔 소리인지..흠.


LDT를 LDTR에 입력하려면, 우선 GDT에 LDT에 관한 디스크립터를 만들어야 한다고 한다. 왜??? LDT는 전역이 아니고 프로세스에 대응하는 테이블이기 때문에 GDT와 같은 속성이 아니란다. (뭐… 맥락은….) 그래서 LDT 위치를 GDT에 우선 등록해주고 GDT의 인덱스값을 LDTR에 입력해 주면 지가 알아서 세그먼트 위치, 크기, 속성까지 로딩한다고 한다. (편하네~~~)


mov ax, GDT내의 LDT인덱스값
lldt ax


IDTR에 IDT를 넣는 방법은 GDTR과 유사하다.

struct
{

   unsgined short IDT_SIZE; (256*8-1)
   unsigned int IDT_ADDRESS;
}


256에다가 8(IDT 디스크립터 크기)을 곱하고 빼기 1을 해준단다.
근데 256개의 디스크립터를 모두 생성해 줘야 하는지 모르겠다. 그러니까 256이 아닌 10개만 등록하면 안 되는지 말이다. 흠…뭐 해봐야 알겠지.




A20 GATE


여기까지 세그먼트 셀렉터로 시작해서 디스크립터 테이블, GDTR,LDTR,IDTR까지 꼬리를 물고 배워왔다. 뭐~~ 더 뭐가 필요한지 모르겠지만.. 완전 지친다. 왜 이리 처리해 줘야 하는 게 많은지..

아… 인터넷에서 보호 모드 검색하다 보니 A20 GATE 라는 놈이 등장했다.

앞에서 80286에서 20비트 에서 24비트로 메모리 버스가 늘었다고 했다. 16MB까지…. 헌데 리얼모드에서는 20비트 밖에 못쓴다. 세그먼트:오프셋 이 방식 때문에 말이다. 기존 8086/8088 요넘들은 0xFFFF:000F 까지 메모리를 액세스 할 수 없었다. 왜?? 20비트 넘어가면 이상한 주소가 참조해 버리니 원하는 위치를 벗어나 버리기 때문이다. 암만 0xFFFF:1234 주소로 입력한들 .. 0x1224 주소로 접근한다. 메모리 접근은 20비트니 20비트 이상은 다 없어지는 거지. 근데 80286은 24비트다. 뭔말이냐 하믄  0xFFFF:1234를 주면 0x101224로 접근이 되서 메모리를 읽고 쓸 수 있다는 말이다. 호~~~ 그럼 16M까지 접근 가능하겠네?? 라고 생각했다가 세그먼트:오프셋 주소 지정 방식을 생각해 보니, 웃음만 나왔다. ㅋㅋㅋ  0xFFFF:FFFF = 0x10FFEF 까지만 가능하다. ㅋㅋㅋㅋㅋ 메모리 버스를 24비트로 늘려도 쓸 수 없다 ㅋㅋㅋㅋ 기존 0xFFFFF에서 64kb 정도만 더 쓸 수 있다. ㅋㅋ 아놔 것도 많다면 많은 거지만.. 왜케 웃기지 ㅋㅋㅋㅋ

여튼 0x10FFEF까지 주소의 64kb 메모리라도 더 쓸라면 A20 GATE 요놈을 이용해야 한다. 요놈이 Keyboard 컨트롤러에 달려 있는 요놈을 ON 시켜야 쓸 수 있단다. 왜 키보드 컨트롤러 일까? 라고 의문이 들었지만 오늘 많은 검색질로 인해서 지쳤다….여튼 요놈을 ON 시켜주면 쓸 수 있다고 한다.. 어떻게??? 메모리 버스 21비트에 A20과 AND 연산기와 묶여 있단다. 그래서 A20 GATE에 ON(1)이 되어 있어야지만 21비트에 접근 가능하단다. 왜 굳이 A20 GATE를 달아서 AND 연산 시키는 괴상망측한 짓이 진행되었는지는…..모르겠다. 여튼, 요넘 때문에 보호모드에서 메모리 접근 할 때 문제가 생긴다. 왜??? A20 GATE가 ON이 안되어 있으면 21비트는 항상 0 이기 때문에…. 그래서 보호 모드 넘어 갈 때는 항상 A20 GATE를 켜고 진입해야 한다고 한다.

'프로그래밍 > OS 만들기' 카테고리의 다른 글

OS 만들기 #13 보호모드 진입  (0) 2014.03.27
OS 만들기 #12 - PE 파일 포맷  (0) 2013.09.10
OS 만들기 #10  (0) 2013.08.14
OS 만들기 #9 - 부트로더  (0) 2013.08.14
OS 만들기 #8 - 부트로더  (0) 2013.08.14

자!! FAT32 파일 시스템 분석해서 파일 찾아서 읽어 오는 것까지 다 했다.!! 이제 부트로더에서 파일 찾아서 메모리에 로딩 시키는 일만 남았다. 참 험난한 길이었다. 블로그에 글로 적는 것도 험난했고, 공부하는 것도 험난했다. 뭐 이제 코딩만 남았으니~~

부트로더는 또 어떻게 만드냐!~~~ 아~ 험난하다!!

흠… OS 하나 만들기 정말 힘들다.

우선, 부트로더는 NASM 으로 컴파일 하고 나머지 커널은 Visual Studio C++ 2010에서 컴파일 할 생각이다. 부트로더에서 바로 KERNEL.SYS 파일을 읽어 0x10000에 로딩하고 실행시킬 생각이다.

하지만, 안 된단다.. Visual studio 2010에서 커널 작성 컴파일 방법을 검색 하던 중 부트로더 => KERNEL.SYS (Visual Studio C++)로 실행 시킬 수 없다고 한다!!!!!!!!!


왜!!!!!!!!!! 왜 왜! ??? 왜 안되냐고!~~~~~~~~~~~~~~~~~~


OS 개발 안 해!!!!

ㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠㅠ

에고고고고..


실은 부트로더 에서 KERNEL.SYS를 호출 해서 실행 시킬 수는 있단다. 다만 리얼 모드 에서 보호 모드로 전환 하고 실행 해야 한단다. 리얼 모드는 뭐고 보호 모드가 뭐길래? 안 된다는 것이냐??? 뭐 쏼라 쏼라 영어를 보니 16bit , 32bit가 언급된다. 아마 리얼 모드는 16비트이고 보호 모드는 32비트 인 모양이다. Visual Studio C++ 은 컴파일러가 32비트만 컴파일 된다고 한다. 16비트 컴파일 하려면 아~~~주 낮은 고대 유물과 비슷한 버전의 Visual Studio C++를 사용 하라고 한다.

아놔!~~~

OS만들려다 사람 잡겄다!!!

에고.. 보호모드 로 전환하고 KERNEL.SYS 호출하지 모… 근데 보호모드 예제 코드들을 보니..라인수가 장난이 아니다. 부트로더 512byte로는 어림도 없겠다. 아~~~~~ 미치겠다. VC++에서 인라인 어셈으로 처리해서 KERNEL.SYS 엔트리 포인터 위치에 보호모드 코드 작성 후 실제 커널 코드로 들어가는 부분 방법으로 작성해야 겠다.

아~~ 이 방법도 쉽지 않다. 쉽지 않아. 어렵다!!! 어렵다!!! 모르고 시작 할땐 의욕이 넘쳤는데 이젠 점점 하기가 싫어진다.

그냥 세 분류로 작성 하련다… 생각대로 하기에는 지친다..어렵고..

..

부트로더, 커널로더, 커널  이렇게 세 분류로 계획했다.


메모리 영역

구분

파일

역활

0x7C00

부트로더

BOOTLOADER

- 커널로더를 로드 하고 실행한다.

0x8000

커널로더

OS_LDR.SYS

- 커널 로드한다.
- 보호모드로 전환한다.
- 커널을 실행한다.

0x10000

커널

BARAM.SYS - 커널 실제 동작


꺼림직한 구조지만, 그냥 이렇게 타협?을 봤다. 커널로더에서 공부 할게 많지만 우선은 부트로더가 제일 문제다. ㅠㅠ 아직까지 부트로더에서 헤매고 있다니 ㅠㅠ




- FAT32 부트로더


음…기존 코드에서 BPB 영역(FAT32 정보) 부분만 더 붙여 주고 OS_LDR.SYS 파일 찾아서 로드하고 실행 하는 코드를 만들어야 한다. Baram 이미지 파일내의 0x10000 에서 각 값을 구해서 직접 입력했다.


org 0x7C00
bits 16

BOOTLOADER_ENTRY:
	;; start로 이동한다. (BPB의 영역의 3바이트는 점프 명령 코드로 이용한다. )
	jmp BOOTLOADER_MAIN
	nop ; 코드에서 2바이트 밖에 안되서 nop 1바이트 추가.

;; FAT32 파일시스템 구조
BPB_OEM: db "EOS Boot"				; 8 바이트 OEM 이름..
BPB_BYTE_PER_SECTOR:	dw 512		; 2바이트 섹터당 바이트 크기.
BPB_SECTOR_PER_CLUSTER: db 0x02		; 클러스터당 섹터 갯수
BPB_RESERVED_SECTOR:	dw 0x186E   ;  예약 섹터 갯수
BPB_FAT_NUM:			db 0x02		; FAT 갯수 (FAT1, FAT2 의 카피본을 두므로 보통 2개)
BPB_ROOT_ENTRY_NUMBER:	dw 0x0000	; 루트 디렉토리에 최대 디렉토리 포함할 수 있는 갯수
BPB_FAT16_SECTORS:		dw 0x0000	; FAT16일 때 총 섹터 갯수
BPB_MEDIA_TYPE:			db 0xF8		; 장치 타입 (0xF8 는 하드디스크)
BPB_FAT16_SIZE:			dw 0x0000	; FAT16일때 FAT테이블 크기
BPB_SECTOR_PER_TRACK:	dw 0x003F	; 트랙당 섹터 갯수
BPB_HEADS:				dw 0x00FF 	; 헤드 갯수
BPB_HIDDEN_SECTOR:		dd 0x00000080	; 숨겨진 섹터 갯수
BPB_FAT32_SECTORS:		dd 0x0003E800	; FAT32 파일시스템일 때 총 섹터 갯수
BPB_FAT16_SIZE:			dd 0x000003C9	; FAT32일때 FAT테이블 크기
BPB_EXTENSION_FLAGS:	dw 0x0000		; 확장 플래그 ( 0-3 : 활성화 FAT )
BPB_FILESYSTEM_VER:		dw 0x0000		; FAT32의 버젼
BPB_ROOT_ENTRY_CLUSTER: dd 0x00000002	; 데이터 시작 클러스터 위치
BPB_FILESYSTEM_INFO:	dw 0x0001		; 파일시스템 정보 위치
BPB_BACKUP_BOOT_SECTOR: dw 0x0006		; 백업 부트 섹터 위치
BPB_RESERVED:							; 예약된 정보 
						dd 0x00
						dd 0x00
						dd 0x00
BS_DRIVE:							; 바이오스콜(0x13) 드라이브 정보
						db 0x80
BS_RESERVED1:						; 예약
						db 0x00
BS_BOOT_SIGNATURE:					; 부트 서명 (0x29)
						db 0x29		;
BS_VOLUME_ID:						; 볼륨 시리얼 번호
						dd 0xC1C286C
BS_VOLUME_LABEL:					; 볼륨 레이블명
						dd 0x4E4F204E
						dd 0x414D4520
						dw 0x2020
						db 0x20
BS_FILESYSTEM_TYPE:					; 파일 시스템 이름
						dd 0x46415433
						dd 0x32202020

BOOTLOADER_MAIN:
	cli
	;; CS, DS, ES, & SS을 초기화 하자.
	xor eax, eax
	mov ds, ax
	mov ss, ax
	mov es, ax


제길… 탭을 넣어서 보기 좋게 정리 했더니 여기에 붙여 넣기 하니 저리 되네.. 아 모르겠다.. 그냥 넘어가자.

스택 위치를 잡아야 하는데 0x8000에 커널 로더 OS_LDR.SYS를 로딩한다. 그러니까 0x8000으로 스택 주소를 잡는다. 뭐 스택은 아래로 감소하면서 포인터가 위치하니까 문제는 없을 것 같다. 그리고 부트로드 드라이버도 변수 하나 생성해서 저장해 주자!!


mov sp, 0x8000     ; 스택을 잡자
mov bp, sp           ; bp 도 0x8000으로 잡자.
mov [DRIVE], dl    ; 현재 드라이브 저장하자.


음…이제 FAT32 접근해야 하는데…..


1. 루트 디렉토리 엔트리 위치를 구하자.
2. FAT 테이블 위치를 구하자.
3. 클러스터당 몇 바이트 인지 구하자.
4. 현재 클러스터 위치를 저장하자.
5. 루트 디렉토리 엔트리 가서 파일명을 읽어서 OS_LDR.SYS를 찾는다.
6. OS_LDR.SYS의 데이터 클러스터로 이동해서 읽는다.
7. FAT 테이블 위치로 가서 OS_LDR.SYS 데이터가 더 있는지 확인한다.
8. 6,7번을 반복한다.
9. OS_LDR.SYS를 실행한다. (이동)


위와 같이 한번 설계해 봤다. 이 구조로 한번 코딩 해 봐야지~


	; 루트 디렉토리 엔트리 위치를 구하자.
	; 루트 디렉토리 엔트리 = (FAT 갯수 * FAT 테이블크기) + 예약 섹터 + 히든 섹터
	mov al, [BPB_FAT_NUM]	
	mov ebx, [BPB_FAT32_SIZE]
	mul ebx		; AL * EBX = EAX
	xor ebx, ebx ; EBX를 0으로 초기화 하자.
	mov bx, [BPB_RESERVED_SECTOR] ; 예약 섹터를 bx 저장.
	add eax, ebx	; EAX = EAX + EBX
	mov ebx, [BPB_HIDDEN_SECTOR] ; 히든 섹터를 ebx로 저장.
	add eax, ebx	; EAX = EAX + EBX
	mov [ROOT_ENTRY], eax

	; FAT1 위치를 찾자.
	; FAT1 = 예약 섹터 + 히든 섹터
	xor eax, eax	; eax는 0으로 초기화 한다.
	mov ax, [BPB_RESERVED_SECTOR] ; 예약 섹터를 ax 저장.
	add eax, ebx	; ebx 는 이미 히든 섹터가 저장되어 있다.
	mov [FAT1], eax

	; 클러스터를 바이트로 변환하자.
	; 클러스터 총 바이트 = (섹터당 바이트 * 클러스터당 섹터 갯수)
	xor ebx, ebx
	mov ax, [BPB_BYTE_PER_SECTOR]
	mov bl, [BPB_SECTOR_PER_CLUSTER]
	mul bx	; EAX = AX * BX  총 바이트를 구했다.
	mov [CLUSTER_BYTES], eax
	
	; 현재 위치 클러스터를 저장하자.
	mov eax, [BPB_ROOT_ENTRY_CLUSTER]
	mov [CURRENT_CLUSTER], eax

; 변수를 선언하자.
DRIVE		db 0x00
ROOT_ENTRY	dd 0x00
FAT1		dd 0x00
CLUSTER_BYTES	dd 0x00
CURRENT_CLUSTER dd 0x00


1,2,3,4번을 구현했다. 여기까지는 순조롭다.

이제 루트 디렉토리 엔트리 위치를 로딩해서 OS_LDR.SYS를 찾아야 한다. 파일 로딩하는 함수를 만들어야 하는데~~


READ_SECTOR:
	pusha				; 모든 레지스터를 스택에 넣는다.
	mov ah, 0x02		; 디스크 읽기 모드
	mov al, 5			; 1 섹터만 읽는다.
	mov ch, 0			; 트랙은 0번 트랙
	mov cl, 2			; 읽을 섹터는 2번째 섹터
	mov dh, 0			; 헤드는 0번 헤드
	mov dl, [DRIVE_NUM] ; 읽을 드라이브 번호
	mov bx, 0x1000		; 0x9000 메모리에 커널 이미지 올린다.
	mov es, bx
	mov bx, 0x0000
	int 0x13			; 읽어라!

	popa
	ret	


루트 디렉토리 엔트리 위치는 섹터 번호로 기록되어 있다. 이걸 트랙 하고 헤드,섹터 이렇게 다시 재 계산 해야 한다.

트랙, 헤드를 구하는 식은 검색해 보니 이렇게 한다고 한다.


트랙 = 총섹터 / (헤드 갯수 * 트랙당 섹터수)
헤드 = (총섹터/트랙 당 섹터수) % 헤드 갯수
섹터 = (총섹터 % 트랙 당 섹터) + 1


식을 보면서 생각해 보니 대충 그림이 그려진다. 그렇다고 이걸 어셈으로 바꾸긴 힘들었다. 이해와 구현의 괴리감…인터넷에 있는 걸로 만들었다.^^


	; 헤드, 트랙, 섹터로 재 계산해서 저장하자.
	; 트랙 = 총섹터 / (헤드 갯수 * 트랙당 섹터수)
	; 헤드 = (총섹터/트랙 당 섹터수) % 헤드 갯수
	; 섹터 = (총섹터 % 트랙 당 섹터) + 1
	; EAX 는 총섹터 값이 있다.
CONVERT_CHS:
	xor dx, dx	; dx를 0으로 초기화 하자.
	mov cx, [BPB_SECTOR_PER_TRACK]
	div cx	; AX / CX = AX , AX % CX = DX

	inc dl	; 나머지 + 1 = 섹터다.
	mov [SECTOR], dl

	xor dx, dx	; dx를 0으로 초기화 하자. ax는 총섹터/트랙 당 섹터수 값이 있다.
	mov cx, [BPB_HEADS]
	div cx	; (총섹터/트랙 당 섹터수) / 헤드수 = 트랙, (총섹터/트랙 당 섹터수) % 헤드수 = 헤드

	mov [HEAD], dl
	mov [TRACK], al
	ret


위와 같이 만들었다. 이제 섹터 읽는 부분을 구현해야 겠다~


READ_SECTOR:
	pusha				; 모든 레지스터를 스택에 넣는다.
	mov ah, 0x02		; 디스크 읽기 모드
	mov al, [READ_SIZE]	; 읽을 섹터
	mov ch, [TRACK]		; 트랙
	mov cl, [SECTOR]	; 섹터
	mov dh, [HEAD]		; 헤드
	mov dl, [DRIVE_NUM] ; 읽을 드라이브 번호
	mov bx, [READ_MEMORY]	; 읽는 데이터 저장될 메모리
	mov es, bx
	mov bx, 0x0000
	int 0x13			; 읽어라!

	popa
	ret	


아주 쉽게 구현되었다. ㅎㅎ

이제 5번을 구현해 봐야지!~


FILE_FIND:
	; 파일이름을 찾자. 
	mov ax, [0x9000]	; 0x9000에 루트 디렉토리 엔트리 데이터 존재.

FIND_LOOP:
	add ax, 0x20		; 첫 데이터는 C:\ 데이터므로 넘어간다.

	// 파일 이름을 비교한다.
	mov si, ax	
	mov di, OS_LDR_FILENAME
	mov cx, 11
	repe cmpsb

	jnz FIND_LOOP

	; 파일을 찾았다.!!! ^^

	; 데이터 클러스터 위치를 구하자.
	mov ax, [si+9]	; 클러스터 상위 2바이트
	push ax
	mov ax, [si+15]	; 클러스터 하위 2바이트
	push ax
	pop eax
	mov [CURRENT_CLUSTER], eax


어셈 문법 찾아보면서 하려니 너무 진도가 더디다. 좀 쉬어야 겠다… 머리 쥐나겠다.

….

;; creator : cyj (mangg@manggong.org)
;; date : 2012. 4. 17
;; desc : BPB bootloader on FAT32
;;        1. FAT32를 분석한다.
;;        2. OS_LDR.sys파일을 FAT32 파일 시스템에서 찾아서 0x8000 번지로 로드한다.
;;        3. OS_LDR.sys데이터가 있는 0x8000으로 이동한다.

org 0x7C00
bits 16

BOOTLOADER_ENTRY:
	;; start로 이동한다. (BPB의 영역의 3바이트는 점프 명령 코드로 이용한다. )
	jmp BOOTLOADER_MAIN
	nop ; 코드에서 2바이트 밖에 안되서 nop 1바이트 추가.

;; FAT32 파일시스템 구조
BPB_OEM: db "EOS Boot"				; 8 바이트 OEM 이름..
BPB_BYTE_PER_SECTOR:	dw 512		; 섹터당 바이트 크기.
BPB_SECTOR_PER_CLUSTER: db 0x02		; 클러스터당 섹터 갯수
BPB_RESERVED_SECTOR:	dw 0x186E   ;  예약 섹터 갯수
BPB_FAT_NUM:			db 0x02		; FAT 갯수 (FAT1, FAT2 의 카피본을 두므로 보통 2개)
BPB_ROOT_ENTRY_NUMBER:	dw 0x0000	; 루트 디렉토리에 최대 디렉토리 포함할 수 있는 갯수
BPB_FAT16_SECTORS:		dw 0x0000	; FAT16일 때 총 섹터 갯수
BPB_MEDIA_TYPE:			db 0xF8		; 장치 타입 (0xF8 는 하드디스크)
BPB_FAT16_SIZE:			dw 0x0000	; FAT16일때 FAT테이블 크기
BPB_SECTOR_PER_TRACK:	dw 0x003F	; 트랙당 섹터 갯수
BPB_HEADS:				dw 0x00FF 	; 헤드 갯수
BPB_HIDDEN_SECTOR:		dd 0x00000080	; 숨겨진 섹터 갯수
BPB_FAT32_SECTORS:		dd 0x0003E800	; FAT32 파일시스템일 때 총 섹터 갯수
BPB_FAT32_SIZE:			dd 0x000003C9	; FAT32일때 FAT테이블 크기
BPB_EXTENSION_FLAGS:	dw 0x0000		; 확장 플래그 ( 0-3 : 활성화 FAT )
BPB_FILESYSTEM_VER:		dw 0x0000		; FAT32의 버젼
BPB_ROOT_ENTRY_CLUSTER: dd 0x00000002	; 데이터 시작 클러스터 위치
BPB_FILESYSTEM_INFO:	dw 0x0001		; 파일시스템 정보 위치
BPB_BACKUP_BOOT_SECTOR: dw 0x0006		; 백업 부트 섹터 위치
BPB_RESERVED:							; 예약된 정보 
						dd 0x00
						dd 0x00
						dd 0x00
BS_DRIVE:							; 바이오스콜(0x13) 드라이브 정보
						db 0x80
BS_RESERVED1:						; 예약
						db 0x00
BS_BOOT_SIGNATURE:					; 부트 서명 (0x29)
						db 0x29		;
BS_VOLUME_ID:						; 볼륨 시리얼 번호
						dd 0xC1C286C
BS_VOLUME_LABEL:					; 볼륨 레이블명
						dd 0x4E4F204E
						dd 0x414D4520
						dw 0x2020
						db 0x20
BS_FILESYSTEM_TYPE:					; 파일 시스템 이름
						dd 0x46415433
						dd 0x32202020

BOOTLOADER_MAIN:
	cli
	;; CS, DS, ES, & SS을 초기화 하자.
	xor eax, eax
	mov ds, ax
	mov ss, ax
	mov es, ax

	mov sp, 0x8000  ; 스택포인터를 잡자.
	mov bp, sp		; bp도 0x8000으로 잡자.
	sti

	mov [DRIVE], dl	; 현재 드라이브를 저장하자.

	; 루트 디렉토리 엔트리 위치를 구하자.
	; 루트 디렉토리 엔트리 = (FAT 갯수 * FAT 테이블크기) + 예약 섹터 + 히든 섹터
	mov al, [BPB_FAT_NUM]	
	mov ebx, [BPB_FAT32_SIZE]
	mul ebx		; AL * EBX = EAX
	xor ebx, ebx ; EBX를 0으로 초기화 하자.
	mov bx, [BPB_RESERVED_SECTOR] ; 예약 섹터를 bx 저장.
	add eax, ebx	; EAX = EAX + EBX
	mov ebx, [BPB_HIDDEN_SECTOR] ; 히든 섹터를 ebx로 저장.
	add eax, ebx	; EAX = EAX + EBX
	mov [ROOT_ENTRY], eax

	; FAT1 위치를 찾자.
	; FAT1 = 예약 섹터 + 히든 섹터
	xor eax, eax	; eax는 0으로 초기화 한다.
	mov ax, [BPB_RESERVED_SECTOR] ; 예약 섹터를 ax 저장.
	add eax, ebx	; ebx 는 이미 히든 섹터가 저장되어 있다.
	mov [FAT1], eax

	; 클러스터를 바이트로 변환하자.
	; 클러스터 총 바이트 = (섹터당 바이트 * 클러스터당 섹터 갯수)
	xor ebx, ebx
	mov ax, [BPB_BYTE_PER_SECTOR]
	mov bl, [BPB_SECTOR_PER_CLUSTER]
	mul bx	; EAX = AX * BX  총 바이트를 구했다.
	mov [CLUSTER_BYTES], eax

	mov eax, 0x0800
	mov [LDR_MEMORY], eax
		
	; 현재 위치 클러스터를 저장하자.
	mov eax, [BPB_ROOT_ENTRY_CLUSTER]
	mov [CURRENT_CLUSTER], eax

	; 0x9000 에 임시로 루트 디렉토리 엔트리를 읽어서 저장해 놓자.
	mov ax, 0x0900	; ES 세그먼트
	mov [READ_MEMORY], ax

FILE_LIST:
	mov ebx, [ROOT_ENTRY]	; 루트 디렉토리 섹터 위치.
	mov eax, [CURRENT_CLUSTER]
	sub eax, 2
	add eax, ebx

	call CONVERT_CHS	; 헤드, 트랙, 섹터로 변환한다.
	call READ_SECTOR	; 데이터를 읽는다.

FILE_FIND:
	; 파일이름을 찾자. 
	mov ax, [0x9000]	; 0x9000에 루트 디렉토리 엔트리 데이터 존재.

FIND_LOOP:
	add ax, 0x20		; 첫 데이터는 C:\ 데이터므로 넘어간다.

	; 파일 이름을 비교한다.
	mov si, ax	
	mov di, OS_LDR_FILENAME
	mov cx, 11
	repe cmpsb

	mov ebx, [CLUSTER_BYTES]
	add ebx, 0x9000
	cmp eax, ebx
	je NO_FIND

	jnz FIND_LOOP

	; 파일을 찾았다.!!! ^^

	; 데이터 클러스터 위치를 구하자.
	mov ax, [si+9]	; 클러스터 상위 2바이트
	push ax
	mov ax, [si+15]	; 클러스터 하위 2바이트
	push ax
	pop eax
	mov [CURRENT_CLUSTER], eax

LOOP_DATA_READ:
	call DATA_READ	; 데이터 클러스터에서 데이터 읽기
	call FAT_SEARCH	; FAT 테이블에서 다음 클러스터를 찾는다.
	cmp al, 0x01	; al에 다음 클러스터가 있으면 0x00, 없으면 0x01 
	je RUN_LDR		; 다음 클러스터가 없으면 OS_LDR 실행하러 가자.
	jmp LOOP_DATA_READ	; 다음 데이터 클러스터 읽으로 가자.

RUN_LDR:
	jmp 0x8000		; 0x8000(OS_LDR.SYS) 실행하자.

	; 루트 디렉토리 엔트리에서 OS_LDR.SYS를 못 찾으면
	; 루트 디렉토리 엔트리의 다음 클러스터를 찾아서
	; 파일 목록을 비교 하러간다.
NO_FIND:
	call FAT_SEARCH	; FAT 테이블에서 다음 클러스터를 찾자.
	cmp al, 0x00	; 다음 클러스터를 찾으면 0x00 
	je FILE_FIND	; 다시 파일이름 찾으로 가자.
	jmp $			; 다음 클러스터가 없으면 무한루프.

	; 데이터 클러스터에서 데이터를 읽어서
	; LDR_MEMORY에 로딩하자.
DATA_READ:
	mov ax, [LDR_MEMORY]	
	mov [READ_MEMORY], ax	; READ_MEMORY에 LDR_MEMORY 복사하자. (세그먼트임을 기억하자)
	mov al, [BPB_SECTOR_PER_CLUSTER]
	mov [READ_SIZE], al	; 클러스터(섹터 2) 만큼 읽자.
	mov ebx, [ROOT_ENTRY]	; 루트 디렉토리 섹터 위치.
	mov eax, [CURRENT_CLUSTER] ; 현재 클러스터.
	sub eax, 2		; 클러스터가 2부터 시작한다고 하니 2를 뺀다.
	add eax, ebx	; EAX = EAX-EBX. EAX는 루트디렉토리부터 현재 클러스터(-2) 더한값.

	call CONVERT_CHS	; 헤드, 트랙, 섹터로 변환한다.
	call READ_SECTOR	; 데이터를 읽는다.

	mov ax, [LDR_MEMORY]	; 데이터를 읽었으니까 데이터 주소를
	mov ebx, [CLUSTER_BYTES]	; 읽은 만큼 증가시켜준다.(클러스터의 바이트수)
	shr ebx, 4	; 세그먼트 계산법에 의해 4바이트 빼 버린다.
	add ax, bx	
	mov [LDR_MEMORY], ax	; 데이터 읽을만큼 LDR_MEMORY를 증가.

	ret

	; FAT 테이블에서 다음 클러스터를 찾자.
FAT_SEARCH:
	; FAT 리스트
	; 0x9000 에 임시로 FAT테이블을 읽어서 저장해 놓자.
	mov ax, 0x0900	; ES 세그먼트
	mov [READ_MEMORY], ax

	; FAT 테이블의 클러스터는 4바이트 이루어져 있으므로
	; 512 / 4 = 128 . 한 섹터당 128개의 클러스터로 이루어져 있다.
	; 현재 클러스터의 FAT 테이블에서 위치를 찾아보자.
	; 현재클러스터 / 128 은 FAT에서 클러스터 위치.
	mov al, 1
	mov [READ_SIZE], al	; FAT 테이블은 섹터 하나만 읽자.
	mov eax, [CURRENT_CLUSTER]
	mov bx, [BPB_BYTE_PER_SECTOR]
	shr bx, 2	; 4로 나누자.
	xor edx, edx
	div ebx	; 128로 AX를 나누자.
	push edx	; AX를 128로 나눈 나머지는 DX로.
	add eax, [FAT1] ; 나눈 몫에 FAT테이블 위치를 더한다.

	; FAT 테이블을 읽자.
	call CONVERT_CHS	; 헤드, 트랙, 섹터로 변환한다.
	call READ_SECTOR	; 데이터를 읽는다.

	pop edx	; 나눠서 나머지 스택에서 빼내고.
	mov esi, 0x9000	;
	sal edx, 2	; 클러스터 X 4 = 클러스터 메모리 위치.
	add esi, edx	; 0x9000 + 클러스터 메모리 위치.
	mov eax, [esi]	; eax에 현재 클러스터의 다음 클러스터값을 읽자.

	cmp eax, 0x0FFFFFFF	; 끝이라면
	jz FAT_END			; al에 0x01 실패!
	
	mov [CURRENT_CLUSTER], eax	; 다음 클러스터를 저장.
	mov al, 0			; al에 0x00 성공!
	ret

FAT_END:
	mov al, 1
	ret

	; 헤드, 트랙, 섹터로 재 계산해서 저장하자.
	; 트랙 = 총섹터 / (헤드 갯수 * 트랙당 섹터수)
	; 헤드 = (총섹터/트랙 당 섹터수) % 헤드 갯수
	; 섹터 = (총섹터 % 트랙 당 섹터) + 1
	; EAX 는 총섹터 값이 있다.
CONVERT_CHS:
	xor dx, dx	; dx를 0으로 초기화 하자.
	mov cx, [BPB_SECTOR_PER_TRACK]
	div cx	; AX / CX = AX , AX % CX = DX

	inc dl	; 나머지 + 1 = 섹터다.
	mov [SECTOR], dl

	xor dx, dx	; dx를 0으로 초기화 하자. ax는 총섹터/트랙 당 섹터수 값이 있다.
	mov cx, [BPB_HEADS]
	div cx	; (총섹터/트랙 당 섹터수) / 헤드수 = 트랙, (총섹터/트랙 당 섹터수) % 헤드수 = 헤드

	mov [HEAD], dl
	mov [TRACK], al
	ret
	
READ_SECTOR:
	pusha				; 모든 레지스터를 스택에 넣는다.
	mov ah, 0x02		; 디스크 읽기 모드
	mov al, [READ_SIZE]	; 읽을 섹터 수
	mov ch, [TRACK]		; 트랙
	mov cl, [SECTOR]	; 섹터
	mov dh, [HEAD]		; 헤드
	mov dl, [DRIVE] ; 읽을 드라이브 번호
	mov bx, [READ_MEMORY]	; 읽는 데이터 저장될 메모리
	mov es, bx
	mov bx, 0x0000
	int 0x13			; 읽어라!

	popa
	ret	

; 변수를 선언하자.
DRIVE		db 0x00
ROOT_ENTRY	dd 0x00
FAT1		dd 0x00
CLUSTER_BYTES	dd 0x00
CURRENT_CLUSTER dd 0x00
READ_MEMORY		dw 0x00
READ_SIZE		db 0x00
SECTOR			db 0x00
TRACK			db 0x00
HEAD			db 0x00
LDR_MEMORY		dw 0x00

OS_LDR_FILENAME db "OS_LDR  SYS",0

	times 510-($-$$) db 0x00
	dw	0xAA55


쉬는 동안 6,7,8,9 구현해 봤다. 하고 보니 완전 길다~  컴파일 될지도 모르겠고 동작 되는지도 모르겠다. 그냥 말 그대로 그냥 구현했다.

error : TIMES value –13 is negative


제길 … 컴파일 안 된다. 요건 왜 이러냐..


510-($-$$) 요거 때문에 생기는 에러란다. (현재위치 – 첫 위치) 가 510 바이트를 넘는다는 거지~~ 512… 아니…이것보다는 적은 공간에 작성하려니 너무 적다. 아 … 어떻게 해야 하나…


변수를 저렇게 잡지 않고 메모리 영역 하나 잡아서 선언하는 방법을 인터넷에서 검색하다가 찾았다.


DRIVE		equ 0x500
ROOT_ENTRY	equ 0x501
FAT1		equ 0x505
CLUSTER_BYTES	equ 0x509
CURRENT_CLUSTER	equ 0x50D
READ_MEMORY		equ 0x511
READ_SIZE		equ 0x513
SECTOR			equ 0x514
TRACK			equ 0x515
HEAD			equ 0x516
LDR_MEMORY		equ 0x517


요렇게 하고 컴파일 해보니 호~~~ 된다. 동작은 될련지는 미지수다…내가 만든 코드지만 솔직히 못 믿겠다. 문법도 맞는지도….그냥 막코딩!!!!

검증을 하기 위해서 전번에 만들어 두었던 코드로 테스트 해봐야 겠다.


ORG 0x8000			; 0x8000 메모리에서 실행되므로 0x8000 으로 주소정렬
BITS 16

	cli				; 인터럽트 발생안되게 설정
	xor ax,ax		; ax 0으로 초기화 한다. ax xor ax 어차피 0이다.
	mov ds, ax		; ds 세그먼트 레지스터를 0 으로 초기화 한다.
	mov es, ax		; es 세그먼트 레지스터를 0 으로 초기화 한다.
	mov ss,ax
	mov sp,0xffff
	sti				; 인터럽트 발생 설정

	lea si, [LOAD_MSG]	; LOAD_MSG 위치 주소
	call PRINT			; PRINT 함수 호출

	jmp $

PRINT:
	pusha				; 모든 레지스터를 스택에 넣는다.
PRINT_LOOP:
	mov al, [si]		; al에 글자 하나 저장한다.
	inc si				; si 주소를 증가한다.
	or al, al			; or 연산. 
	jz PRINT_END		; 문자열 끝이 or 연산이 0 이라면. 종료
	mov ah,0x0E			; ah = 0xE
	int 0x10			; 인터럽트 0x10h
	jmp PRINT_LOOP		; 다음 문자 출력 루프	

PRINT_END:
	popa				;모든 레지스터 스택에서 뺀다.
	ret					;호출 한곳으로 리턴.

LOAD_MSG:
	db "LOAD MY KERNEL", 0x00

	times 510-($-$$) db 0x00
	dw	0xAA55


요걸 OS_LDR.SYS 이름으로 컴파일 한다.

nasm –fbin –o OS_LDR.SYS OS_LDR.ASM


파티션 부트로더에 컴파일 한 코드 붙여 넣고, 이걸 다시 [제어판][관리 도구][컴퓨터관리] 가서 VHD 연결 해서 드라이브로 연결해서 OS_LDR.SYS를 넣었다. 잘 될까?

 

'프로그래밍 > OS 만들기' 카테고리의 다른 글

OS 만들기 #10  (0) 2013.08.14
OS 만들기 #9 - 부트로더  (0) 2013.08.14
OS 만들기 #7 - FAT32  (1) 2013.08.14
OS 만들기 #6 - MBR  (0) 2013.08.14
OS 만들기 #5 - 부트로더  (0) 2013.08.14

부트로더 #4

BaramOS이미지의 첫번째 섹터의 데이터에 내가 입력하지 않는 데이터가 기록되어 있다. 이건 도대체 무엇일까?

또 검색질을 해본다. 아 MBR …


MBR이란?

마스터 부트 레코드 또는 파티션된 기억 장치의 첫 섹터 인 512 바이트 시동 섹터이다. MBR은 다음의 것들 가운데 하나 이상을 위해 사용된다.
디스크 프라이머리 파티션 테이블을 소유한다. 부트스트래핑 운영 체제 32비트 디스크 서명이 있는 각 디스크 매체의 구별 IBM PC 호환 컴퓨터의 대중화 때문에, 지원을 넓히고 다른 컴퓨터 통합하기 위해 이러한 종류의 MBR이 널리 사용된다.  - 위키백과


새로만든 BaramOS 이미지의 파일의 첫번째 섹터의 데이터는 윈도우즈가 디스크 초기화 메뉴에서 MBR 항목에서 선택했을 때 알아서 기록했던 데이터 인것이다. MBR은 파티션 정보를 담을 수 도 있고 , 없을 수도 있단다. 파티션 없는 저장 매체 일 경우 없겠지!~~ 음. http://www.terms.co.kr/MBR.htm 에서는 다음과 같이 설명한다.


MBR[엠비알]은 운영체계가 어디에, 어떻게 위치해 있는지를 식별하여 컴퓨터의 주기억장치에 적재될 수 있도록 하기 위한 정보로서 하드디스크디스켓의 첫 번째 섹터에 저장되어 있다. MBR은 또한 "파티션 섹터" 또는 "마스터 파티션 테이블"이라고도 불리는데, 그 이유는 하드디스크가 포맷될 때 나뉘어지는 각 파티션의 위치에 관한 정보를 가지고 있기 때문이다. 그외에도, MBR은 메모리에 적재될 운영체계가 저장되어 있는 파티션의 부트 섹터 레코드를 읽을 수 있는 프로그램을 포함하고 있는데, 부트 섹터 레코드에는 다시 운영체계의 나머지 부분들을 메모리에 적재시키는 프로그램을 담고 있다.


디스크 파티션을 나눴을 때, 그 정보를 디스크 첫번째 섹터에 담고 있나 보다.

자, 그러면 난 뭐해야 하냐??? 이 1섹터를 내 부트로더로 덮어써야 하는건가?? 검색질(^^)


아~


윈도우 기본 MBR은 활성화된 파티션을 찾아서 그 해당 파티션의 부트레코드를 0x7C00 메모리에 올리는 실행권을 넘긴다고 한다.


그냥 둬도 되겠네… 파티션 부트 레코드를 내 부트로더로 덮어 씌우면 되겠다. 그 전에

파티션.. 좀더 MBR 파티션 정보에 대해서 알아 봐야 겠다.


MBR은 446바이트의 부트코드 랑 16바이트 씩 4개의 파티션 정보를 지니고 있다고 한다. 뭐 내 관심은 446 부트코드는 아니니 넘어가고, 4개의 파티션 정보좀 살펴 봐야 겠다.


파티션 구조

오프셋

길이

내용

0x00

1

파티션 상태 (0x80 : 시동가능 ….)

0x01

3

파티션 첫번째 섹터의 트랙/헤더/섹터 주소

0x04

1

파티션 종류

0x05

3

파티션 마지막 트랙/헤더/섹터 주소

0x08

4

파티션 첫번째 섹터의 LBA

0x0C

4

파티션의 크기


4개의 파티션이 위와 같은 구조로 되어 있다고 한다. MBR은 이 4개의 파티션을 읽어서 파티션 상태 0x80 인 파티션을 찾아서 파티션 첫번째 섹터의 읽고 실행시킨다는 거지. 여튼 여긴 손댈곳이 없는 것 같다. 파티션의 첫번째 섹터만 찾아서 내 부트로더만 넣으면 되겠지.



MBR 의 부트코드가 446라니깐 그 뒤는 파티션 정보는 0x1BE 에 있다.



BaramOS 이미지 파일은 파티션이 하나이므로 뭐 볼 필요는 없겠지만, 첫번째 파티션 정보는 위 그림의 영역 까지다. 한번 나눠보자.

파티션 상태(1) : 0x80(0x80 = 시동 가능, 0x00 = 부팅불가, 기타 = 비정상)
파티션 첫번째 섹터 (3) : 0x000302
파티션 종류(1) : 0x0B(
http://www.win.tue.nl/~aeb/partitions/partition_types-1.html)
파티션 끝 셋터(3) : 0x0F21F0
파티션 첫번째 섹터 LBA : 0x00000080
파티션 크기(섹터갯수) : 0x0003E800

* 리틀 인디안


음. 부팅이 가능 0x80 상태고 FAT32 시스템이라고 파티션 정보에 나와 있다. LBA 는 뭐지???

오!!! int 13 으로 파일 읽을 때 트랙/헤드/섹터 요렇게 구분해 가지고 파일 읽었는데 LBA는 그냥 0부터 ~~쭉 섹터 번호를 읽는게 LBA 라는거네!~ 어쩐지 트랙/헤드/섹터 요거 읽는 거 불편했는데 직관적인 LBA 가 있었네.. 이제 LBA 방식으로 파일을 읽도록 해야 겠다. 트랙/헤드/섹터 요건 영~~~직관적이지 않아!!!!


자 그럼 내 부트로더를 덮어 씌울 파티션 부트섹터 영역으로 넘어가봐야 겠다. 파티션 정보에 LBA에 0x00000080 이라니깐 0x80 섹터 뒤에 있다는 거네!! 0x80 X 512 = 0x10000 이니깐 헥사뷰어 0x10000로 이동!!!



윈도우즈 7 에서 포맷 했더니 요놈은 포맷 하면서 윈도우 기본 부트로더 까지 넣었나 보다. 뭔가 쭉 채워져 있다.



'프로그래밍 > OS 만들기' 카테고리의 다른 글

OS 만들기 #8 - 부트로더  (0) 2013.08.14
OS 만들기 #7 - FAT32  (1) 2013.08.14
OS 만들기 #5 - 부트로더  (0) 2013.08.14
OS 만들기 #4 - 부트로더  (0) 2013.08.14
OS 만들기 #3 - 부트로더  (1) 2013.08.14

부트로더 #2

이제 커널을 로드 해서 커널 실행코드로 넘겨주면 될 것 같다. ㅋ 이 두려운 어셈블리어에서 빨리 벗어나고픈 생각 뿐이다.

이제 파일을 로드 하는 방법에 대해서 검색질 해봐야 겠다. 파일을 읽는 방법은 int 13h 인터럽트를 사용하면 된다고 한다. 근데 사용 방법이 거의 이해하기 어려운 수준이다. 섹터, 트렉, 헤드.. 많이 들어본 용어긴 하지만 그냥 언어적 이해만 할 뿐이지, 실제 데이터 읽고, 쓰는 방법에 대해선 전혀 모른다. 이것 먼저 공부해야 한다. 휴~ 겁나 귀찮고 어렵고 지루하다.

INT 13h 를 사용하여 데이터를 읽는 방법은 다음과 같다.


파라미터

AH 0x02 읽기 ( 0x03 : 쓰기)
AL 읽을 섹터 수.
CH 트랙 번호
CL 읽을 섹터 번호
DH 헤드번호
DL 드라이브 번호
ES:BX 읽은 데이터를 저장할 위치

결과

CF 에러시 플래그가 설정됨.
AH 리턴 코드
AL 읽은 섹터 갯수

그러면 트랙, 섹터, 헤드 가 뭔지를 알아보자.

인터넷에서 검색하다가 찾은 그림이다. 그림을 보니 이해가 된다.

트랙 디스크판에서 원형으로 줄 그어 놓은 영역
섹터 트랙을 부채꼴 모양으로 줄 그어 나눈 구간
헤드 디스크 윗면과 밑면을 읽는 구분.


각각 트랙과 헤드는 0 부터 시작하고 섹터는 1부터 시작한다고 한다. 컴퓨터가 부트로드 영역을 찾을 수 있었던 건 0 트랙, 1섹터에 접근해서 그냥 1섹터를 읽기 때문이기 때문이군..뭐 대충 이해는 간다. 근데 왜이리 복잡한 방법으로 구현해 놓은거냐!~~흠..

나의 커널 데이터는 0트랙 2섹터에 저장해 놓고 이걸 읽으면 되겠군. 아싸 드뎌 진도가 조금 나갔다!!!

헉 프로그래밍 하다 보니까 int 13h 에서 쓰는 DL 레지스터 값 드라이브 번호는 어떻게 적어줘야 하냐 ㅡㅡ;;; 문제에 봉착했다. 검색질 해보니 0x00 은 플로피 디스크 , 0x80 부터는 하드디스크 번호라고 하는데… 나의 이미지 파일은 하드 디스크 이므로 0x80 이라고 주어줘도 된다. 근데 만약 플로피 인지 하드디스크 인지 알고 싶으면??? 검색해보자!! 검색 할 단어 조차도 모르겠다 ㅠㅠ 여튼 부트로더 로 검색 해봐야지~~~ 영어에 일본어에 모르는 글자 들 ㅠㅠ 어렵다…어려워

에휴! 컴퓨터가 부트로더 올리고 DX의 DL 의 부팅한 번호를 기록해서 부트로더로 점프한다고 한다. dl 레지스터가 변경되지 않은 한 dl에 부팅 드라이브 번호가 기록된단다.. 검색하느라 겁나 오래 걸렸다. 아무튼 변수 하나 만들어서 이것도 기록해 놔야 겠다.

ORG 0x7C00
BITS 16

	cli				; 인터럽트 발생안되게 설정
	xor ax,ax		; ax 0으로 초기화 한다. ax xor ax 어차피 0이다.
	mov ds, ax		; ds 세그먼트 레지스터를 0 으로 초기화 한다.
	mov es, ax		; es 세그먼트 레지스터를 0 으로 초기화 한다.
	sti				; 인터럽트 발생 설정

	mov [DRIVE_NUM], dl	; 부팅한 드라이브 번호를 DRIVE_NUM 변수에 저장.

	lea si, [HELLO_MSG]	; HELLO_MSG 위치 주소
	call PRINT			; PRINT 함수 호출

	call READ_SECTOR	; 커널 이미지를 읽어라

	jmp 0x9000			; 메모리 0x9000으로 이동해라.

READ_SECTOR:
	pusha				; 모든 레지스터를 스택에 넣는다.
	mov ah, 0x02		; 디스크 읽기 모드
	mov al, 1			; 1 섹터만 읽는다.
	mov ch, 0			; 트랙은 0번 트랙
	mov cl, 2			; 읽을 섹터는 2번째 섹터
	mov dh, 0			; 헤드는 0번 헤드
	mov dl, [DRIVE_NUM] ; 읽을 드라이브 번호
	mov bx, 0x9000		; 0x9000 메모리에 커널 이미지 올린다.
	int 0x13			; 읽어라!

	popa
	ret	
PRINT:
	pusha				; 모든 레지스터를 스택에 넣는다.
PRINT_LOOP:
	mov al, [si]		; al에 글자 하나 저장한다.
	inc si				; si 주소를 증가한다.
	or al, al			; or 연산. 
	jz PRINT_END		; 문자열 끝이 or 연산이 0 이라면. 종료
	mov ah,0x0E			; ah = 0xE
	int 0x10			; 인터럽트 0x10h
	jmp PRINT_LOOP		; 다음 문자 출력 루프	

PRINT_END:
	popa				;모든 레지스터 스택에서 뺀다.
	ret					;호출 한곳으로 리턴.

HELLO_MSG:
	db "HELLO MY BOOTLOADER", 0x0D,0x0A,0x00

DRIVE_NUM db 0x00
	
	times 510-($-$$) db 0x00
	dw	0xAA55

자, 부트로더는 이렇게 작성해 놓고…커널 이미지를 만들면 된다. 음.. 동작 되는지 확인 할겸 화면에 문자열을 출력하는 기능만 갖도록 하자.  완전 흥분된다!

ORG 0x9000			; 0x9000 메모리에서 실행되므로 0x9000 으로 주소정렬
BITS 16

	cli				; 인터럽트 발생안되게 설정
	xor ax,ax		; ax 0으로 초기화 한다. ax xor ax 어차피 0이다.
	mov ds, ax		; ds 세그먼트 레지스터를 0 으로 초기화 한다.
	mov es, ax		; es 세그먼트 레지스터를 0 으로 초기화 한다.
	sti				; 인터럽트 발생 설정

	lea si, [LOAD_MSG]	; LOAD_MSG 위치 주소
	call PRINT			; PRINT 함수 호출

	jmp $

PRINT:
	pusha				; 모든 레지스터를 스택에 넣는다.
PRINT_LOOP:
	mov al, [si]		; al에 글자 하나 저장한다.
	inc si				; si 주소를 증가한다.
	or al, al			; or 연산. 
	jz PRINT_END		; 문자열 끝이 or 연산이 0 이라면. 종료
	mov ah,0x0E			; ah = 0xE
	int 0x10			; 인터럽트 0x10h
	jmp PRINT_LOOP		; 다음 문자 출력 루프	

PRINT_END:
	popa				;모든 레지스터 스택에서 뺀다.
	ret					;호출 한곳으로 리턴.

LOAD_MSG:
	db "LOAD MY KERNEL", 0x00

	times 510-($-$$) db 0x00
	dw	0xAA55

자 컴파일..

nasm –fbin –o bootloader bootloader.asm
nasm –fbin –o kernel kernel.asm

깔끔하게 컴파일 된다 ^^ 자~ bootloader 하고 kernel 을 Visual studio에서 헥사뷰어로 로드 하고 … 가상 이미지 파일도 로드 하고 512 바이트씩 복사해서 붙여보자…

자~~ 가상 컴퓨터 ~~~

HELLO MY BOOTLOADER
LOAD MY KERNEL

우하하하!! 된다!!! ㅋㅋㅋ

이거 은근히 가슴이 벅차다.. 이제 커널까지 로드 했으니, 본격적으로 커널 만들어서 띄우면 되겠다 ! ^^ 우선, 부트로더 랑 커널을 이미지 파일에 넣는 거 불편하니, 프로그램 하나 만들어 주고!!~ 가만 커널이 커지면 부트로더 에서 섹터 읽어 오는 부분을 변경해줘야 하네!! 흠…지금은 512바이트만 읽어오는 구조니 커널 먼저 만들고 크기 계산해서 부트로더 섹터 읽어 오는 갯수를 늘려줘야 하는 구조네…음…

그냥 파일 크기 알아서 오는 방법은 없나?? 흠.. 커널 만들어서 그냥 복사 해주는 방식으로.. 흠.. 아~~악, 내가 만든 부트로더랑 커널은 파일 시스템이 전혀 고려 안된 구조다!!!

그냥 부트로더 만든다고 나머지 설렁설렁 봤더니 , ㅠㅠ 파일시스템을 고려 했어야 했는데!!! 다시 파일시스템을 고려한 부트로드를 만들어야 한다. (아놔! 어셈블리어 또 …ㅠㅠ) 아, 지친다.. 하기 싫다.. 파일 시스템은 만들어야 하나, 있던거 써야 하나 .. 리눅스 ext2?? 윈도우 FAT??? 이거 뭘 써야 하나~

'프로그래밍 > OS 만들기' 카테고리의 다른 글

OS 만들기 #6 - MBR  (0) 2013.08.14
OS 만들기 #5 - 부트로더  (0) 2013.08.14
OS 만들기 #3 - 부트로더  (1) 2013.08.14
OS 만들기 #2  (0) 2013.08.14
OS 만들기 #1  (0) 2013.08.14

부트로더 #1

부트로더를 만들어야 하는데, 어셈블리어 잘 모르는데 난감하다. 몇 번 훑어 본 걸로 만들 수 있을 지 모르겠다. 다른 부트로더를 참조해서 만들어야 겠다. 그래 (ㅠㅠ 나의 영혼이여~~ ) 근데, 부트로더는 어떻게 실행 할까? 라는 궁금증이 생겼다. 자 검색..검색..

음… 대충 컴퓨터가 전원이 켜질 경우 , 저장 매체의 첫 번째 섹터에서 512 바이트를 정해진 메모리에 로딩하고 해당 메모리를 프로그램으로 인식하고 실행한다. 라고 이해했다. 그러니까 첫 번째 섹터 512바이트를 읽어서 그걸 실행한다는 거군. 쉽네. 근데 왜 512바이트지?? 검색..검색.. 흠 못 찾겠다.

자 , 그러면 프로그래밍 한번 해보자!!! 아직, 부트로더 설계도 제대로 잡지 않았는데…음… 흠.

그냥 HELLO 한번 찍어 보자.

   1: mov ax, 0    ; ax 레지스터를 0 으로 초기화 한다.
   2: mov ds, ax   ; ds 세그먼트 레지스터를 0으로 초기화 한다.
   3: mov es, ax   ; es 세그먼트 레지스터를 0으로 초기화 한다.

아직 여기밖에 모르겠다. 화면에 출력하려면 어떻게 하지?? 히유!! 답답하다…또 검색질 하자.

어셈블리어를 이용해서 화면에 글자를 출력하려면 BIOS 인터럽트 를 이용해야 한다고 하네.. 그래 인터럽트 한번 더 뒤져보자.

http://ko.wikipedia.org/wiki/%EB%B0%94%EC%9D%B4%EC%98%A4%EC%8A%A4_%EC%9D%B8%ED%84%B0%EB%9F%BD%ED%8A%B8_%ED%98%B8%EC%B6%9C 여기에 인터럽트 테이블 모아놓은 게 있네. INT 10h 이용하면 되겠다.

mov al, ‘a’
mov ah, 0x0E
int 10h

이걸 이용해서 다시 프로그래밍 한다.

	cli				; 인터럽트 발생안되게 설정
	xor ax,ax		; ax 0으로 초기화 한다. ax xor ax 어차피 0이다.
	mov ds, ax		; ds 세그먼트 레지스터를 0 으로 초기화 한다.
	mov es, ax		; es 세그먼트 레지스터를 0 으로 초기화 한다.
	sti				; 인터럽트 발생 설정

	lea si, [HELLO_MSG]	; HELLO_MSG 위치 주소
	call PRINT			; PRINT 함수 호출

	
PRINT:
	pusha				; 모든 레지스터를 스택에 넣는다.
PRINT_LOOP:
	mov al, [si]		; al에 글자 하나 저장한다.
	inc si				; si 주소를 증가한다.
	or al, al			; or 연산. 
	jz PRINT_END		; 문자열 끝이 or 연산이 0 이라면. 종료
	mov ah,0x0E			; ah = 0xE
	int 0x10			; 인터럽트 0x10h
	jmp PRINT_LOOP		; 다음 문자 출력 루프	

PRINT_END:
	popa				;모든 레지스터 스택에서 뺀다.
	ret					;호출 한곳으로 리턴.

HELLO_MSG:
	db "HELLO MY BOOTLOADER", 0x00

자 코드 입력은 했고 , 컴파일 해야지~~~^^

nasm –fbin –o BOOTLOADER BOOTLOADER.ASM

캬~~ 에러도 없다. BOOTLOADER 라는 파일이 생성 되었다.

자 이제 이걸 첫 번째 섹터에 복사해 주면 된다.  아~ 난 가상이미지 파일인데?? 어떻게 이걸 복사하지?? 아놔!!! ..흠…이미지 파일이니까 그냥 이미지 파일 찾아서 해당 첫 번째에다가 복사하면 되나?? 생각 난 김에 해보자!! 근데 이거 원… 가상 이미지 파일 있는 위치를 모르겠네 ㅡㅡ;;;

1. Windows Virtual PC 를 실행한다.
2. 생성한 가상 컴퓨터를 선택한다.
3. 설정 을 클릭한다.
4. 하드 디스크 1을 선택한다.
5. 가상 이미지 파일 위치를 찾았다!

 자 , vhd 확장자의 이미지 파일을 찾았다. ㅎㅎ 이제 에디터로 불러야지~~. 음… 울트라 에디터로 로딩할 까, Visual Studio 로 로딩 할까?? 아무래도 복사해야 하니 Visual Studio 에서 로딩 해야 할것 같다. 아악!! 128MB 다. 왜 이렇게 크게 만들었을까 ..ㅠㅠ 다시 만들까?? 귀찮다!!! 그냥 읽어 버렷!

깔끔하게 헥사뷰어 로 나온다. 울트라 에디트 보단 이게 좋지~^^ 아 부트로더 도 읽어야지~~Visual Studio에 부트로더 도 읽어 준다. 탭으로 왔다 갔다 하면 편하겠네..부트로더 헥사뷰어에서 코드를 이제 복사한다. 컴퓨터가 512바이트를 읽는다고 했으니, 512바이트를 복사하면 되겠다. 라인이 1f0까지 쭉 내려서 복사한다. 그리고 이미지 파일 헥사뷰어에서 똑같이 1f0 라인까지 선택 후, 붙이기 한다. 그리고 저장.!!!!

긴장된다. Windows Virtual PC 실행해서 가상 컴퓨터 작동해봐야지~~

한참을 기다려도 실행 안된다. 검은 화면…..이미지 파일 첫 부분에 파일 붙이기 하는게 안되는 건가?? 흠.. 인터넷에서 돌아다니는 부트로더로 컴파일 해서 복사, 붙이기 하니 화면이 뜬다. 이미지 파일 첫 부분에 붙이기 하는건 되는건가 보다. 내가 만든 코드는 아니지만 가상 컴퓨터 화면에 뭔가 출력은 되니, 쪼금 나도 희망이 생긴다. 음.. 뭐가 문제지?? 되는 부트로더 랑 비교해 보자!!

크게 다른 부분은 첫 부분하고 끝 부분이다.

times 510-($-$$) db 0x00
dw 0xAA55

이건 또 무슨 문법이야 ? 하고 검색해 보니, times 는 뭘 반복할 때 쓴다고 한다. $는 현재 위치를 나타내는 거고, $$줄 처음 위치를 나타내는 거란다. 그러면 저 명령어 들의 하는 짓은??? 그냥 510까지 0으로 채우는 짓이란다. 즉 내가 만든 코드는 50 바이트 밖에 안된다. 510-50 = 460 바이트를 0으로 다 채운다는 것이다. 어차피 0으로 다 채워져 있는데 뭘!! 흠.. 그리고 dw 0xAA55는 510 이후에 AA55라고 쓰기 위해서란다. 왜???? 컴퓨터가 512 바이트를 읽고 0xAA55 저놈이 있나 없나 체크 한단다!! 없으면 실행 안 해 준다네…

흠.. 그러니까 512 바이트 중 끝에 0xAA55가 있어야지 우선 실행해 준다는 거네. 그러면 코드에 times랑 0xAA55 넣고 컴파일….다시 가상 PC 작동…..오~~~~~~~~~~~~~~~~~ 뭔가 나온다!!!

아드래날린이 왕성하게 분비 되는지 흥분된다. 하하하 . 흠 근데 왜 글자가 안나오고 쓰레기값이 나오냐?? 코드 문제인가? 흠.. 동작하는 부트로더랑 비교해 봐야겠네…

첫부분에

org 0x7C00
bits 16

이 있다. 뭐 뒤에 쓰잘데기 없이 점프 명령어 있긴 한데 뭐 필요 없는 작업인것 같고… 요 두넘이 틀리다. 또 뭐하는 놈들이냐?? 검색..검색…(검색질도 지겹다 …)

ORG 0x7C00 : 컴퓨터가 내가 만든 부트로더를 0x7C00 메모리 위치에다가 로딩하는데, 내 부트로더는 데이터 변수 쓸때 그 데이터 변수 위치가 0으로 시작된 위치에 있으므로 찾지 못한다. 고로 첫줄에 똭!!!! 0x7C00 부터 시작 되게 하면 그 데이터를 쓸 수 있게 해준단다!

BITS 16 : 내가 작성하는게 16비트에서 작동하는 코드를 사용한다는 명령어란다. 흠!

뭐 이리 어렵나~~ 여튼 추가…

ORG 0x7C00 
BITS 16

    cli                ; 인터럽트 발생안되게 설정 
    xor ax,ax        ; ax 0으로 초기화 한다. ax xor ax 어차피 0이다. 
    mov ds, ax        ; ds 세그먼트 레지스터를 0 으로 초기화 한다. 
    mov es, ax        ; es 세그먼트 레지스터를 0 으로 초기화 한다. 
    sti                ; 인터럽트 발생 설정

    lea si, [HELLO_MSG]    ; HELLO_MSG 위치 주소 
    call PRINT            ; PRINT 함수 호출

    jmp $

    
PRINT: 
    pusha                ; 모든 레지스터를 스택에 넣는다. 
PRINT_LOOP: 
    mov al, [si]        ; al에 글자 하나 저장한다. 
    inc si                ; si 주소를 증가한다. 
    or al, al            ; or 연산. 
    jz PRINT_END        ; 문자열 끝이 or 연산이 0 이라면. 종료 
    mov ah,0x0E            ; ah = 0xE 
    int 0x10            ; 인터럽트 0x10h 
    jmp PRINT_LOOP        ; 다음 문자 출력 루프   

PRINT_END: 
    popa                ;모든 레지스터 스택에서 뺀다. 
    ret                    ;호출 한곳으로 리턴.

HELLO_MSG: 
    db "HELLO MY BOOTLOADER", 0x00

    times 510-($-$$) db 0x00 
    dw    0xAA55

나 울뻔 했다…된다..

HELLO MY BOOTLOADER

화면에 출력된다. 검색 질 하느라 시간 보냈는데 출력이 되니 기쁘다. 이제 커널 파일 만들어서 부트로더에서 로딩시키고 커널 실행시키면 되겠다. 하하 이제 C 로 넘어간다. 알지도 못하는 어셈블리어로 벗어 난다니 더 기쁘다.

'프로그래밍 > OS 만들기' 카테고리의 다른 글

OS 만들기 #6 - MBR  (0) 2013.08.14
OS 만들기 #5 - 부트로더  (0) 2013.08.14
OS 만들기 #4 - 부트로더  (0) 2013.08.14
OS 만들기 #2  (0) 2013.08.14
OS 만들기 #1  (0) 2013.08.14

+ Recent posts