Все выпуски  

Пишем свою операционную систему. Переходим на Си


Приветствую всех своих читателей!

Предыдущие выпуски могли быть несколько запутанными. Начальная загрузка, Assembler, BIOS. Сегодня мы наконец переходим к более интересной и понятной части - мы начинаем писать ядро. И писать мы его будем на языке высокого уровня Си.

В начальный загрузчик осталось внести всего пару дополнений и он будет полностью готов грузить любые 32-битные ядра.

Определение объёма оперативной памяти

Конечно, можно подсчитать объём памяти вручную в ядре - перебирать адреса от 0x100000 и пытаться записать туда значение отличное от нуля и 0xFF. Если при чтении мы получаем полученное значение, то всё хорошо, иначе память кончилась - запоминаем адрес последнего удачного чтения, это и будет объёмом оперативной памяти. Однако такой способ имеет два недостатка:

1) Его следует использовать до включения страничной адресации, чтобы иметь доступ ко всей физической памяти, либо устраивать запись через "окно" временной страницы. Лишняя трата времени, при условии, что тестирование памяти BIOS и так выполняет при начальной инициализации, а мы делаем двойную работу.

2) Всё хорошо пока память представляет собой непрерывный участок адресов, но на современных системах с большим объёмом памяти это правило может быть нарушено. К тому же BIOS пишет в самую обычную память таблицы ACPI, которые пригодятся операционной системе и не стоит их затирать до прочтения.

Из этого следует, что лучше спросить про объём оперативной памяти у BIOS, благо он предоставляет все необходимые функции.

Исторически первой функцией определения объёма оперативной памяти было прерывание 0x12. Оно не принимает никаких входных параметров, в на выходе в регистре AX содержится размер базовой памяти в килобайтах. Базовая память - те самые 640 КБ доступные в реальном режиме. Сейчас вы уже не сможете найти компьютер, где бы было менее 640 КБ памяти, но мало ли. Использовать её нам смысла нет - если процессор поддерживает защищённый режим, то вряд ли у него будет меньше нескольких мегабайт памяти.

Объёмы памяти росли и 640 КБ стало мало. Тогда появилась новая функция - прерывание 0x15 AH=0x88. Она возвращает в AX размер расширенной памяти (свыше 1 МБ) в килобайтах в AX. Эта функция не может возвращать значения больше 15 МБ (15 + 1 итого 16 МБ).

Когда и 16 МБ стало недостаточно появилась новая функция - прерывание 0x15, AX=0xE801. Она возвращает результаты аж в 4 регистрах:

AX - размер расширенной памяти до 16 МБ в килобайтах
BX - размер расширенной памяти сверх 16 МБ к блоках по 64 КБ
CX - размер сконфигурированной расширенной памяти до 16 МБ в килобайтах
DX - размер сконфигурированной расширенной памяти сверх 16 МБ в блоках по 64 КБ

Что такое "сконфигурированная" память производители BIOS судя по всему не договорились, поэтому надо просто, если в AX и BX нули, брать значение из CX и DX.

Но и этого оказалось мало. Ведь все перечисленные выше функции имеют ограничение объёма памяти в 4 ГБ, к тому же не учитывают то, что память может быть не непрерывным блоком. Поэтому в новых BIOS появилась ещё одна функция - прерывание 0x15, AX=0xE820. Она возвращает не просто число, а карту памяти. Входные параметры:

EAX=0xE820
EDX=0x534D4150 ("SMAP")
EBX - смещение от начала карты памяти (для начала 0)
ECX - размер буфера (как правило 24 байта - размер одного элемента)
ES:DI - адрес буфера, куда надо записать очередной элемент

Выходные параметры:

EAX=0x534D4150 ("SMAP")
EBX - новое смещение для следующего вызова функции. Если 0, то вся карта памяти прочитана
ECX - количество реально возвращённых байт (20 или 24 байта)
В указанном буфере содержится очередной элемент карты памяти.

Каждый элемент карты памяти имеет следующую структуру (напишу в синтаксисе Си, потому что разбор данных мы будем делать уже в ядре):

struct {
        unsigned long long base; //Базовый физический адрес региона
        unsigned long long length; //Размер региона в байтах
        unsigned long type; // Тип региона
        unsigned long acpi_attrs; //Расширенные атрибуты ACPI
}; 

Последний элемент структуры не обязателен. Ещё в одном источнике видел, что перед запросом элемента стоит поместить туда единичку. Конечно, сейчас мы не поддерживаем ACPI, но лучше заранее позаботится о том, чтобы получить как можно больше данных. В отличии от параметров памяти, всё остальное можно легко узнать и из защищённого режима напрямую, без BIOS.

Регионы памяти, описываемые картой, могут быть нескольких типов:

1 - Обычная память. Может быть свободно использована ОС для своих целей. Пока мы только к ней и будем обращаться, а всё остальное пропускать.
2 - Зарезервировано (например, код BIOS). Эта память может быть как физически недоступна для записи, так и просто запись туда нежелательна. Такую память лучше не трогать.
3 - Доступно после прочтения таблиц ACPI. Вероятно, именно в этих блоках эти таблицы и хранятся. Пока драйвер ACPI не прочитает таблицы, эту память лучше не трогать. Потом можно использовать так же, как и память типа 1.
4 - Эту память следует сохранять между NVS сессиями. Такую память мы трогать не будем, пока не узнаем, что такое NVS сессии :-)

Не все BIOS могут поддерживать эту функцию. Если какая-то функция не поддерживается, то при выходе из неё установлен флаг переполнения и следует обращаться к более старой. Мы будем использовать формат карты памяти функции 0xE820. Если саму эту функцию вызвать не получилось - получать объём памяти обычными средствами и создавать свою собственную карту памяти из одного элемента. Поскольку определение объёма памяти задача нужная и для запуска 32-битного и для запуска 64-битного ядра, лучше оформить её в виде подпрограммы. Карту памяти разместим по адресу 0x7000. Не думаю, что она может быть больше пары килобайт. Последний элемент вручную сделаем типа 0 - такого типа не возвращает BIOS и это и будет признаком конца.

; Получение карты памяти
get_memory_map:
	mov di, 0x7000
	xor ebx, ebx
 @:
	mov eax, 0xE820
	mov edx, 0x534D4150
	mov ecx, 24
	mov dword[di + 20], 1
	int 0x15
	jc @f
	add di, 24
	test ebx, ebx
	jnz @b
 @:
	cmp di, 0x7000
	ja .ok
	mov dword[di], 0x100000
	mov dword[di + 4], 0
	mov dword[di + 12], 0
	mov dword[di + 16], 1
	mov dword[di + 20], 0
	mov ax, 0xE801
	int 0x15
	jnc @f
	mov ah, 0x88
	int 0x15
	jc .ok
	mov cx, ax
	xor dx, dx
 @:
	test cx, cx
	jz @f
	mov ax, cx
	mov bx, dx
 @:
	movzx eax, ax
	movzx ebx, bx
	mov ecx, 1024
	mul ecx
	push eax
	mov eax, ebx
	mov ecx, 65536
	mul ecx
	pop edx
	add eax, edx
	mov [di + 8], eax
	add di, 24
	jmp .ok
 .ok:
	xor ax, ax
	mov cx, 24 / 2
	rep stosw
	ret

 Ну вот и готов наш начальный загрузчик для 32-битных ядер. В заключение привожу его полный код и мы перейдём к ядру.

; Начальный загрузчик ядра для архитектуры x86
format Binary as "bin"
org 0x7C00
	jmp boot
; Заголовок ListFS
align 4
fs_magic dd ?
fs_version dd ?
fs_flags dd ?
fs_base dq ?
fs_size dq ?
fs_map_base dq ?
fs_map_size dq ?
fs_first_file dq ?
fs_uid dq ?
fs_block_size dd ?
; Заголовок файла
virtual at 0x800
f_info:
	f_name rb 256
	f_next dq ?
	f_prev dq ?
	f_parent dq ?
	f_flags dq ?
	f_data dq ?
	f_size dq ?
	f_ctime dq ?
	f_mtime dq ?
	f_atime dq ?
end virtual
; Данные начального загрузчика
label sector_per_track word at $$
label head_count byte at $$ + 2
label disk_id byte at $$ + 3
reboot_msg db "Press any key...",13,10,0
boot_file_name db "boot.bin",0
; Вывод строки DS:SI на экран
write_str:
	push si
	mov ah, 0x0E
 @:
	lodsb
	test al, al
	jz @f
	int 0x10
	jmp @b
 @:
	pop si
	ret
; Критическая ошибка
error:
	pop si
	call write_str
; Перезагрузка
reboot:
	mov si, reboot_msg
	call write_str
	xor ah, ah
	int 0x16
	jmp 0xFFFF:0
; Загрузка сектора DX:AX в буфер ES:DI
load_sector:
	push dx
	add ax, word[fs_base]
	adc dx, word[fs_base + 2]
	cmp byte[sector_per_track], 0xFF
	je .use_EDD
	push bx cx si
	div [sector_per_track]
	mov cl, dl
	inc cl
	div [head_count]
	mov dh, ah
	mov ch, al
	mov dl, [disk_id]
	mov bx, di
	mov al, 1
	mov si, 3
 @:
	mov ah, 2
	int 0x13
	jnc @f
	xor ah, ah
	int 0x13
	dec si
	jnz @b
 .error:
	call error
	db "DISK ERROR",13,10,0
 @:
	pop si cx bx dx
	ret
 .use_EDD:
	push si
	mov byte[0x600], 0x10
	mov byte[0x601], 0
	mov word[0x602], 1
	mov [0x604], di
	push es
	pop word[0x606]
	mov [0x608], ax
	mov [0x60A], dx
	mov word[0x60C], 0
	mov word[0x60E], 0
	mov ah, 0x42
	mov dl, [disk_id]
	mov si, 0x600
	int 0x13
	jc .error
	pop si dx
	ret
; Поиск файла с именем DS:SI в каталоге DX:AX
find_file:
	push cx dx di
 .find:
	cmp ax, -1
	jne @f
	cmp dx, -1
	jne @f
 .not_found:
	call error
	db "NOT FOUND",13,10,0
 @:
	mov di, f_info
	call load_sector
	push di
	mov cx, 0xFFFF
	xor al, al
	repne scasb
	neg cx
	dec cx
	pop di
	push si
	repe cmpsb
	pop si
	je .found
	mov ax, word[f_next]
	mov dx, word[f_next + 2]
	jmp .find
 .found:
	pop di dx cx
	ret
; Загрузка текущего файла в память по адресу BX:0. Количество загруженных секторов возвращается в AX
load_file_data:
	push bx cx dx si di
	mov ax, word[f_data]
	mov dx, word[f_data + 2]
 .load_list:
	cmp ax, -1
	jne @f
	cmp dx, -1
	jne @f
 .file_end:
	pop di si dx cx
	mov ax, bx
	pop bx
	sub ax, bx
	shr ax, 9 - 4
	ret
 @:
	mov di, 0x8000 / 16
	call load_sector
	mov si, di
	mov cx, 512 / 8 - 1
 .load_sector:
	lodsw
	mov dx, [si]
	add si, 6
	cmp ax, -1
	jne @f
	cmp dx, -1
	je .file_end	
 @:
	push es
	mov es, bx
	xor di, di
	call load_sector
	add bx, 0x200 / 16
	pop es
	loop .load_sector
	lodsw
	mov dx, [si]
	jmp .load_list
; Точка входа в начальный загрузчик
boot:
	; Настроим сегментные регистры
	jmp 0:@f
 @:
	mov ax, cs
	mov ds, ax
	mov es, ax
	; Настроим стек
	mov ss, ax
	mov sp, $$
	; Разрешим прерывания
	sti
	; Запомним номер загрузочного диска
	mov [disk_id], dl
	; Определим параметры загрузочного диска
	mov ah, 0x41
	mov bx, 0x55AA
	int 0x13
	jc @f
	mov byte[sector_per_track], 0xFF
	jmp .disk_detected
 @:
	mov ah, 0x08
	xor di, di
	push es
	int 0x13
	pop es
	jc load_sector.error
	inc dh
	mov [head_count], dh
	and cx, 111111b
	mov [sector_per_track], cx
 .disk_detected:
	; Загрузим продолжение начального загрузчика
	mov si, boot_file_name
	mov ax, word[fs_first_file]
	mov dx, word[fs_first_file + 2]
	call find_file
	mov bx, 0x7E00 / 16
	call load_file_data
	; Переходим на продолжение
	jmp boot2
; Пустое пространство и сигнатура
rb 510 - ($ - $$)
db 0x55,0xAA
; Дополнительные данные загрузчика
load_msg_preffix db "Loading '",0
load_msg_suffix db "'...",0
ok_msg db "OK",13,10,0
config_file_name db "boot.cfg",0
start16_msg db "Starting 16 bit kernel...",13,10,0
start32_msg db "Starting 32 bit kernel...",13,10,0
label module_list at 0x6000
label memory_map at 0x7000
; Разбиение строки DS:SI по символу слеша
split_file_name:
	push si
 @:
	lodsb
	cmp al, "/"
	je @f
	test al, al
	jz @f
	jmp @b
 @:
	mov byte[si - 1], 0
	mov ax, si
	pop si
	ret
; Загрузка файла с именем DS:SI в буфер BX:0. Размер файла в секторах возвращается в AX
load_file:
	push si
	mov si, load_msg_preffix
	call write_str
	pop si
	call write_str
	push si
	mov si, load_msg_suffix
	call write_str
	pop si
	push si bp
	mov dx, word[fs_first_file + 2]
	mov ax, word[fs_first_file]
 @:
	push ax
	call split_file_name
	mov bp, ax
	pop ax
	call find_file
	test byte[f_flags], 1
	jz @f
	mov si, bp
	mov dx, word[f_data + 2]
	mov ax, word[f_data]
	jmp @b	
 @:
	call load_file_data
	mov si, ok_msg
	call write_str
	pop bp si
	ret
; Получение карты памяти
get_memory_map:
	mov di, memory_map
	xor ebx, ebx
 @:
	mov eax, 0xE820
	mov edx, 0x534D4150
	mov ecx, 24
	mov dword[di + 20], 1
	int 0x15
	jc @f
	add di, 24
	test ebx, ebx
	jnz @b
 @:
	cmp di, 0x7000
	ja .ok
	mov dword[di], 0x100000
	mov dword[di + 4], 0
	mov dword[di + 12], 0
	mov dword[di + 16], 1
	mov dword[di + 20], 0
	mov ax, 0xE801
	int 0x15
	jnc @f
	mov ah, 0x88
	int 0x15
	jc .ok
	mov cx, ax
	xor dx, dx
 @:
	test cx, cx
	jz @f
	mov ax, cx
	mov bx, dx
 @:
	movzx eax, ax
	movzx ebx, bx
	mov ecx, 1024
	mul ecx
	push eax
	mov eax, ebx
	mov ecx, 65536
	mul ecx
	pop edx
	add eax, edx
	mov [di + 8], eax
	add di, 24
	jmp .ok
 .ok:
	xor ax, ax
	mov cx, 24 / 2
	rep stosw
	ret
; Продолжение начального загрузчика
boot2:
	; Загрузим конфигурационный файл загрузчика
	mov si, config_file_name
	mov bx, 0x1000 / 16
	call load_file
	; Выполним загрузочный скрипт
	mov bx, 0x9000 / 16
	mov bp, module_list
	mov dx, 0x1000
 .parse_line:
	mov si, dx
 .parse_char:
	lodsb
	test al, al
	jz .config_end
	cmp al, 10
	je .run_command
	cmp al, 13
	je .run_command
	jmp .parse_char
 .run_command:
	mov byte[si - 1], 0
	xchg dx, si
	cmp byte[si], 0
	je .parse_line ; Пустая строка
	cmp byte[si], "#"
	je .parse_line ; Комментарий
	cmp byte[si], "L"
	je .load_file ; Загрузка файла
	cmp byte[si], "S"
	je .start ; Запуск ядра
	; Неизвестная команда
	mov al, [si]
	mov [.cmd], al
	call error
	db "Unknown boot script command '"
	.cmd db ?
	db "'!",13,10,0
 .config_end: ; При правильном конфигурационном файле мы не должны сюда попасть
	; Завершение
	jmp reboot
; Загрузка файла
 .load_file:
	push dx
	inc si
	call load_file
	push ax
	mov cx, 512
	mul cx
	mov word[bp + 8], ax
	mov word[bp + 10], dx
	mov word[bp + 12], 0
	mov word[bp + 14], 0
	mov ax, bx
	mov cx, 16
	mul cx
	mov word[bp], ax
	mov word[bp + 2], dx
	mov word[bp + 4], 0
	mov word[bp + 6], 0
	pop ax
	shr ax, 9 - 4
	add bx, ax
	add bp, 16
	pop dx
	jmp .parse_line
; Запуск ядра
 .start:
	; Проверим, что загружен хотя бы один файл
	cmp bx, 0x9000 / 16
	ja @f
	call error
	db "NO KERNEL LOADED",13,10,0	
 @:
	; Заполняем последний элемент списка файлов
	xor ax, ax
	mov cx, 16
	mov di, bp
	rep stosw
	; Переходим к процедуре инициализации ядра для нужной разрядности
	inc si
	cmp word[si], "16"
	je .start16
	cmp word[si], "32"
	je .start32
	;cmp word[si], "64"
	;je .start64
	; Неизвестная рязрядность ядра
	call error
	db "Invalid start command argument",13,10,0
; Запуск 16-разрядного ядра
 .start16:
	mov si, start16_msg
	mov bx, module_list
	mov dl, [disk_id]
	jmp 0x9000
; Запуск 32-разрядного ядра
 .start32:
	; Выводим уведомление о запуске 32-битного ядра
	mov si, start32_msg
	call write_str
	; Проверим, что процессор не хуже i386
	mov ax, 0x7202
	push ax
	popf
	pushf
	pop bx
	cmp ax, bx
	je @f
	call error
	db "Required i386 or better",13,10,0	
 @:
	; Получим карту памяти
	call get_memory_map
	; Очистим таблицы страниц
	xor ax, ax
	mov cx, 3 * 4096 / 2
	mov di, 0x1000
	rep stosw
	; Заполним каталог страниц
	mov word[0x1000], 0x2000 + 111b
	mov word[0x1FFC], 0x3000 + 111b
	; Заполним первую таблицу страниц
	mov eax, 11b
	mov cx, 0x100000 / 4096
	mov di, 0x2000
 @:
	stosd
	add eax, 0x1000
	loop @b
	; Заполним последнюю таблицу страниц
	mov di, 0x3000
	mov eax, dword[module_list]
	or eax, 11b
	mov ecx, dword[module_list + 8]
	shr ecx, 12
 @:
	stosd
	add eax, 0x1000
	loop @b
	mov word[0x3FF4], 0x4000 + 11b ; Kernel stack
	mov word[0x3FF8], 0x3000 + 11b ; Kernel page table
	; Загрузим значение в CR3
	mov eax, 0x1000
	mov cr3, eax
	; Загрузим значение в GDTR
	lgdt [gdtr32]
	; Запретим прерывания
	cli
	; Перейдём в защищённый режим
	mov eax, cr0
	or eax, 0x80000001
	mov cr0, eax
	; Перейдём на 32-битный код
	jmp 8:start32
; Таблица дескрипторов сегментов для 32-битного ядра
align 16
gdt32:
	dq 0                  ; NULL - 0
	dq 0x00CF9A000000FFFF ; CODE - 8
	dq 0x00CF92000000FFFF ; DATA - 16
gdtr32:
	dw $ - gdt32 - 1
	dd gdt32
; 32-битный код
use32
start32:
	; Настроим сегментные регистры и стек
	mov eax, 16
	mov ds, ax
	mov es, ax
	mov fs, ax
	mov gs, ax
	mov ss, ax
	mov esp, 0xFFFFDFFC
	; Поместим в DL номер загрузочного диска
	mov dl, [disk_id]
	; Поместим в EBX адрес списка загруженных файлов
	mov ebx, module_list
	; Поместим в ESI адрес карты памяти
	mov esi, memory_map
	; Переходим на ядро
	jmp 0xFFC00000 

Первое ядро 

Ядро пока у нас будет состоять из двух файлов - startup.asm и main.c. startup.asm нужен для того, чтобы быть уверенными, что управление попадёт на функцию kernel_main. Ведь она может быть не в начале файла, а содержимое startup.o мы полностью контролируем и если укажем его первым линкеру, то будем управлять и первыми байтами двоичного файла.

format ELF

public _start
extrn kernel_main

section ".text" executable

_start:
	movzx edx, dl
	push edx
	push esi
	push ebx
	lgdt [gdtr]
	call kernel_main
 @:
	;cli
	;hlt
	jmp @b

section ".data" writable

gdt:
	dq 0                 
	dq 0x00CF9A000000FFFF
	dq 0x00CF92000000FFFF
gdtr:
	dw $ - gdt
	dd gdt

 Ну вот и последний наш код на чистом Assembler :-). Он выполняет простейшую задачу - уложить в стек три аргумента для функции kernel_main и передать на неё управление. После возврата из неё ядро уходит в бесконечный цикл. По соглашению вызова функций Си параметры следует пихать в стек в образом порядке. Также этот код инициализации загружает новое значение в GDTR - теперь таблица дескрипторов сегментов находится в пространстве ядра и даже если мы отмонтируем первый мегабайт не произойдёт никаких ошибок.

А теперь самое вкусное - простейшее ядро на языке высокого уровня:

typedef struct {
	unsigned long long base;
	unsigned long long size;
} BootModuleInfo;

void kernel_main(char boot_disk_id, void *memory_map, BootModuleInfo *boot_module_list) {
	char *screen_buffer = (void*)0xB8000;
	char *msg = "Hello world!";
	unsigned int i = 24 * 80;
	while (*msg) {
		screen_buffer[i * 2] = *msg;
		msg++;
		i++;
	}
} 

Это ядро не делает ничего особенного - просто выводит строку "Hello world!" на последнюю строчку текстового экрана. Структура описанная в начале будет нужна для доступа к списку загруженных модулей.

Важно помнить, что никакой стандартной библиотеки у нас нет - нам доступны только те функции, которые мы сделаем сами. Все printf, strcpy, memcpy и т. п. придётся реализовывать самостоятельно, не пытайтесь обратиться к ним. В следующем выпуске мы займёмся созданием нашего собственного жутко урезанного аналога libc, чтобы программировать было удобнее. Тут начинается самая интересная часть, а принятые решения во многом повлияют на всю структуру системы.

Сборка ядра

Исполняемые файлы собираются в два этапа - компиляция, а потом линковка. На первом этапе компилятор преобразует исходный код в команды процессора и сохраняет всё это в объектный файл. Каждый модуль системы сохраняется в отдельном файле. В этом файле так же содержится информация о функциях, описанных в модули, поэтому из одного файла можно свободно вызывать функцию из другого. Весь код в объектных файлах не привязан к конкретным адресам. На втором этапе линкер собирает все объектные файлы в один бинарный. При этом код привязывается к конкретным адресам (если, конечно, мы не собираем динамически загружаемую библиотеку), вместо ссылок на функции подставляются нужные адреса. Нам нужно получить на выходе особый двоичный файл. Это просто код и данные, без каких-либо заголовков (то есть это не PE и не ELF). В качестве базового адреса используется адрес 0xFFC00000. Для упрощения этого мы опишем всё, что нам нужно в специальном формате скрипта ld:

OUTPUT_FORMAT("binary")
ENTRY(_start)

SECTIONS {
 	.text 0xFFC00000 : {
		*(.text)
		*(.code)
		*(.rodata*)
	}
	.data ALIGN(0x1000) : {
		*(.data)
  	}
	.bss ALIGN(0x1000) : {
		*(.bss)
	}
	.empty ALIGN(0x1000) - 1 : {
		BYTE(0)
	}
} 

Этот скрипт говорит, что наш файл будет лежать в памяти непрерывным блоком начиная с адреса 0xFFC00000. В самом начале будет идти секция кода, потом секция read-only данных, затем обычных данных, потом неинициализированных. Все секции выровнены на размер страницы 4 КБ (вдруг мы потом захотим защитить на уровне таблицы страниц код от записи). Последнее описание секции .empty необходимо для того, чтобы даже неинициаилизорованные переменные занимали место в файле (там будут нули). Ведь начальный загрузчик выделяет память для ядра руководствуясь размером файла.

Собрать всё ядро можно следующими командами:

fasm startup.asm startup.o
gcc -c -m32 -ffreestanding -o main.o main.c
ld --oformat=binary -melf_i386 -T script.ld -o kernel.bin startup.o main.o 

Параметр GCC -ffreestanding указывает ему отключить все стандартные библиотеки. Ведь они привязаны к конкретной операционной системе, а мы пишем новую.

Сборка образа диска

Обойдусь без лишних комментариев и просто приведу линуксовый скрипт сборки образа:

dd if=bin/boot.bios.bin of=bin/boot_sector.bin bs=512 count=1
dd if=bin/boot.bios.bin of=disk/boot.bin bs=1 skip=512
cp bin/kernel.bin disk/kernel.bin
bin/make_listfs of=disk.img bs=512 size=2880 boot=bin/boot_sector.bin src=./disk  

Он предполагает, что все скомпилированные файлы лежат в bin в текущем каталоге, а ещё имеется каталог disk, в котором лежит boot.cfg следующего содержания:

# Loading kernel
Lkernel.bin
# Boot 32 bit kernel
S32 

Если вы всё сделали правильно, полученный образ можно запустить в эмуляторе или даже на реальном железе и вы получите подобную картину:

 Загрузчик считывает конфигурационный файл, загружает ядро, переходит в защищённый режим и передаёт ему управление. Получив его, наше ядро выводит последнюю строку на экран. Это лишь начало долгого пути, мы переходим к самой интересной части разработки. Теперь выпуски будут гораздо более простым для восприятия, благодаря использованию языка высокого уровня, который как я надеюсь все и так знают. Если вы не хотите разбираться с Assembler, можете просто взять мой готовый загрузчик и startup.asm и изменять уже только содержимое main.c, поскольку весь код до этого не диктует жёстко какие-либо параметры ядра (кроме ФС с которой мы загружаемся) и позволяет построить на своей базе что угодно.

Автоматизация сборки или Makefile

Вы могли заметить, что вручную набивать столько команд достаточно утомительно. К тому же не всегда есть необходимость перекомпилировать все файлы. Например, если startup.asm не был изменён, можно не вызывать fasm. Специально для упрощения компиляции приложений была придумана утилита make, которая входит в стандартную поставку GCC и MinGW.

Любой Makefile стоит из набора правил с такой структурой:

ИмяЦелиИлиФайла: ИмяПервогоИсходногоФайла ИмяВторогоИсходногоФайла
...
        КомандыКомпиляции 

Первое правило, которое должно быть в любом Makefile - цель all. make смотрит на зависимости цели all и компилирует их, а затем выполняет команды и этой цели. Для каждой другой цели сначала собираются её зависимости. При этом имя цели и имя зависимостей могут совпадать с именами реальных файлов. В таком случае пересборка цели произойдёт только если исходники были изменены.

Ещё одна цель, которая часто используется в Makefile - clean. Её задача удалить все бинарные файлы, чтобы начать сборку "с чистого листа". Вот так может выглядеть Makefile для ядра:

all: startup.o main.o script.ld
	ld --oformat=binary -melf_i386 -T script.ld -o kernel.bin startup.o main.o
startup.o: startup.i386.asm
	fasm startup.i386.asm startup.o
main.o: main.c
	gcc -c -m32 -ffreestanding -o main.o main.c
clean:
	rm -v *.o kernel.bin 

Этот текст необходимо сохранить в файл с именем Makefile (без расширения) в каталог с исходными текстами ядра. Теперь достаточно выполнить команду make без параметров, находясь в этом каталоге и мы получим файл kernel.bin (либо сообщения об ошибках, если что-то пошло не так).

А вот так я собираю загрузчик:

all: boot.bios.bin
boot.bios.bin: boot.bios.asm
	fasm boot.bios.asm boot.bios.bin
clean:
	rm -v boot.bios.bin 

 ... и make_listfs:

all: compile
compile: make_listfs.c
	gcc -o make_listfs make_listfs.c
clean:
	rm -f make_listfs make_listfs.exe 

Ну и наконец расскажу про вызов других Makefile из одного. Я достаточно ленив, чтобы даже заходить в каталоги с каждым компонентом системы, поэтому создал 1 Makefile, который собирает сразу всю систему. У меня есть папка src, в ней подкаталоги: boot, kernel, make_listfs. В самой src находится вот такой Makefile:

all:
	make -C boot/
	make -C kernel/
	make -C make_listfs/
clean:
	make -C boot/ clean
	make -C kernel/ clean
	make -C make_listfs clean 

 Теперь, находясь в каталоге src я просто пишу make и получаю полностью собранную систему, а если написать make clean, то все двоичные файлы будут удалены и останутся только исходники.

Ну и в довершение последний скрипт, который выполняет полную компиляцию и сборку всех компонентов и образа диска. В одном каталоге с ним надо разместить src, пустой каталог bin и каталог disk с файлом boot.cfg.

#!/bin/sh
make -C src
cp src/boot/boot.bios.bin bin/
cp src/kernel/kernel.bin bin/
cp src/make_listfs/make_listfs bin/

dd if=bin/boot.bios.bin of=bin/boot_sector.bin bs=512 count=1
dd if=bin/boot.bios.bin of=disk/boot.bin bs=1 skip=512
cp bin/kernel.bin disk/kernel.bin
bin/make_listfs of=disk.img bs=512 size=2880 boot=bin/boot_sector.bin src=./disk 

read -p "Press Enter to continue..." dummy 

С таким набором скриптов сборка система становится предельно простой, особенно если учесть, что последний скрипт можно запускать двойным кликом из файлового менеджера. Различные команды вроде dd, cp, rm не существуют под Windows, поэтому её пользователям пригодится пакет MSYS или Cygwin. Однако простая сборка всех компонентов будет работать даже если у вас есть только GCC и fasm (make_listfs легко скомпилируется и запустится в виде Windows-приложения).

Примечание для пользователей ОС Windows

ld для Windows не совсем полноценный - он не поддерживает вывод сразу в бинарный файл, только в EXE. Исправить это можно создав сначала EXE (ld не обратит внимание, что базовые адреса секций невозможные для вендовых бинарников), а потом вытащить оттуда чистые данные с помощью objcopy. Если вы столкнётесь с тем, что ld отказывается создавать файл kernel.bin, воспользуйтесь вот таким Makefile для ядра:

all: startup.o main.o script.ld
	ld -melf_i386 -T script.ld -o kernel.bin startup.o main.o
	objcopy kernel.bin -O binary
startup.o: startup.i386.asm
	fasm startup.i386.asm startup.o
main.o: main.c
	gcc -c -m32 -ffreestanding -o main.o main.c
clean:
	rm -v *.o kernel.bin

 Заодно уберите строку OUTPUT_FORMAT("binary") из script.ld. Теперь и под Windows получится собрать ядро системы.

Загрузка системы на реальной машине

После таких успехов у некоторых может возникнуть желание опробовать новую ОС на реальном железе. Это не представляет проблем. С помощью HxD в Windows откройте дискету или флешку, выбрав вариант "Открыть диск". При открытии флешки важно открыть именно саму флешку, а не её раздел. В другой вкладке откройте disk.img, выделите его содержимое полностью и скопируйте на диск с его самого начала. После этого можно нажать "Сохранить" и дождаться окончания записи. Все данные на флешке или дискете при этом будут уничтожены, а для того, чтобы её использовать снова по назначению, её придётся заново отформатировать!

Пользователи Linux могут поступить проще - выполнить специальную команду в терминале. Для дискеты:

dd if=disk.img of=/dev/fd0 

Для флешки:

dd
if=disk.img of=/dev/sdX 

Вместо sdX надо подставить настоящее имя устройства (sda, sdb, sdc, sdd и т. д.). Главное при этом не перепутать и не записать образ на системный диск, уничтожив все данные. Разумеется, обе команды должны выполняться от имени root или с помощью sudo.

После этого надо настроить в BIOS загрузку с дискеты или флешки (старые BIOS не поддерживают флешки) и наслаждаться видом "Hello world".

Заключение

Ну вот собственно и всё на сегодня. Мы наконец-то закончили программирование на Assembler (хотя в С всё равно придётся иногда делать ассемблерные вставки для работы с оборудованием) и перешли на язык высокого уровня. Ещё очень много предстоит сделать. Мы можете уже проводить различные эксперименты, изменяя мой main.c, только учтите, что любая ошибка (доступ к неспроецированной памяти, деление на ноль) приведёт к перезагрузке или зависанию системы (мы пока не обрабатываем исключения, поэтому процессор не может продолжить работу после ошибки). До встречи!

Любые вопросы вы можете задать на мой адрес: kiv.apple@gmail.com. И да, сейчас самое время для различных идей по концепции ОС и предложений.


В избранное