Как написать загрузочный сектор

Эта статья представляет собой ознакомительный материал о написании загрузчика на С и Ассемблере. Сразу скажу, что здесь я не буду вдаваться в сравнение производительности итогового кода, созданного на этих языках. В этой работе я просто вкратце изложу процесс создания загрузочного флоппи-образа путем написания собственного кода с последующим его внедрением в загрузочный сектор устройства. Все содержание будет разделено на цикл из трех статей, так как сразу сложно изложить всю нужную информацию и о компьютерах, и об устройствах загрузки, и о написании самого кода. В первой части я поясню наиболее общие аспекты компьютерной науки и суть процесса загрузки, а также обобщу значение и важность каждого этапа, чтобы упростить их понимание и запоминание.

О чем пойдет речь?

Мы рассмотрим написание кода программы и его копирование в загрузочный сектор образа флоппи-диска, после чего с помощью эмулятора bochs (x86) для Linux научимся проверять работоспособность полученной дискеты с загрузчиком.

О чем речь не пойдет

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

Структура статьи

Начнем мы со знакомства с основами, после чего перейдем к написанию самого кода. В целом план будет такой:

• Знакомство с загрузочными устройствами.
• Знакомсто со средой разработки.
• Знакомство с микропроцессором.
• Написание кода на ассемблере.
• Написание кода на С.
• Создание мини-программы для отображения прямоугольников.

К сведению: эта статья окажется наиболее полезной, если у вас уже есть хоть какой-то опыт программирования. Несмотря на ее ознакомительный характер, написание загрузочных программ на ассемблере и C может оказаться непростой задачей. Поэтому новичкам в программировании я рекомендую сначала ознакомиться с базовыми вводными материалами и уже потом возвращаться к этому.

Здесь я буду постепенно описывать процесс в форме вопросов и ответов, попутно приводя различную компьютерную терминологию. Вообще, я написал это руководство так, как будто обращаю его самому себе. A дискуссионный формат выбрал, потому что лично мне он помогает лучше понять важность и назначение рассматриваемого материала в повседневной жизни.

Знакомство с загрузочными устройствами

Что происходит при включении стандартного компьютера?

Обычно при нажатии кнопки включения питания от нее подается сигнал блоку питания о необходимости подачи необходимого напряжения на внутреннее и внешнее оборудование компьютера, такое как процессор, монитор, клавиатура и пр. Процессор при этом инициализирует ПЗУ-чип BIOS (базовую систему ввода/вывода) для загрузки содержащейся в нем исполняемой программы, именуемой также — BIOS.

После запуска BIOS выполняет следующие задачи:
• Тестирование оборудования при подаче питания (Power On self Test).
• Проверка частоты и доступности шин.
• Проверка системных часов и аппаратной информации в CMOS RAM.
• Проверка настроек системы, предустановок оборудования и т.д.
• Тестирование подключенного оборудования, начиная с RAM, дисководов, оптических приводов, HDD и т.д.
• В зависимости от определенной в разделе загрузочных устройств информации выполняет поиск загрузочного диска и переходит к его инициализации.

К сведению: все ЦПУ с архитектурой x86 в процессе загрузки запускаются в реальном режиме (Real Mode).

Что такое загрузочное устройство?

Загрузочным называется устройство, содержащее загрузочный сектор или блок загрузки. BIOS считывает это устройство, начиная с загрузки этого загрузочного сектора в RAM для выполнения, после чего переходит далее.

Что такое сектор?

Сектор – это особый раздел загрузочного диска, размер которого обычно составляет 512 байт. Чуть позже я подробнее поясню о том, как измеряется память компьютера и приведу сопутствующую терминологию.

Что такое загрузочный сектор?

Загрузочный сектор или блок загрузки – это область загрузочного устройства, в которой содержится загружаемый в RAM машинный код, за что отвечает встроенная в ПК прошивка на стадии инициализации. На флоппи-диске размер сектора составляет 512 байт. Чуть позже о байтах будет сказано дополнительно.

Как работает загрузочное устройство?

При его инициализации BIOS находит и загружает первый сектор (загрузочный) в RAM и начинает его выполнение. Расположенный в загрузочном секторе код является первой программой, которую можно отредактировать для определения дальнейшего функционирования компьютера после его запуска. Здесь я имею в виду, что вы можете написать собственный код и скопировать его в загрузочный сектор, чтобы система работала так, как вам нужно. Сам же этот код и будет называться тем самым начальным загрузчиком.

Что такое начальный загрузчик?

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

Какие есть виды микропроцессоров?

Я приведу основные:
• 16 битные
• 32 битные
• 64 битные

Чем больше значение бит, тем к большему объему памяти имеют доступ программы, получая большую производительность в плане временного хранилища, обработки и пр. На сегодня микропроцессоры производят две основные компании – Intel и AMD. В этой же статьи я буду обращаться только к процессорам семейства Intel (x86).

В чем отличие процессоров Intel и AMD?

Каждый производитель использует свой уникальный способ проектирования микропроцессоров с аппаратной точки зрения и в плане используемых наборов инструкций.

Знакомство со средой разработки

Что такое реальный режим?

Я уже упоминал, что все процессоры с архитектурой x86 при загрузке с устройства запускаются в реальном режиме. Это очень важно иметь в виду при написании загрузочного кода для любого устройства. Реальный режим поддерживает только 16-битные инструкции. Поэтому создаваемый вами код для загрузки в загрузочную запись или сектор должен компилироваться в 16-битный формат. В реальном режиме инструкции могут работать только с 16 битами одновременно. Например, в 16-битном ЦПУ конкретная инструкция будет способна складывать в одном цикле два 16-битных числа. Если же для процесса будет необходимо сложить два 32-битных числа, то потребуется больше циклов, выполняющих сложение 16-битных чисел.

Что такое набор инструкций?

Это гетерогенная коллекция сущностей, ориентированных на конкретную архитектуру микропроцессора, с помощью которых пользователь может взаимодействовать с ним. Здесь я подразумеваю коллекцию сущностей, состоящую из внутренних типов данных, инструкций, регистров, режимов адресации, архитектуры памяти, обработки прерываний и исключений, а также внешнего I/O. Обычно для семейства микропроцессоров создаются общие наборы инструкций. Процессор Intel-8086 относится к семейству 8086, 80286, 80386, 80486, Pentium, Pentium I, II, III, которое также известно как семейство x86. В этой статье я будут использовать набор инструкций, относящийся именно к этому типу процессоров.

Как написать код для загрузочного сектора устройства?

Для реализации этой задачи необходимо иметь представление о:
• Операционной системе (GNU Linux).
• Ассемблере (GNU Assembler).
• Наборе инструкций (x86).
• Написании инструкций на GNU Assembler для x86 микропроцессоров.
• Компиляторе (как вариант язык C).
• Компоновщике (GNU linker ld)
• Эмуляторе x86, например bochs, используемом для тестирования.

Что такое операционная система?

Объясню очень просто. Это большой набор различных программ, написанных сотнями и даже тысячами профессионалов, которые помогают пользователям в решении их повседневных задач. К таким задам можно отнести подключение к интернету, общение в соцсетях, создание и редактирование файлов, работу с данными, игры и многое другое. Все это реализуется с помощью операционной системы. Помимо этого, ОС также регулирует функционирование аппаратных средств, обеспечивая для вас оптимальным режим работы.

Отдельно отмечу, что все современные ОС работают в защищенном режиме.
Какие виды ОС бывают?
• Windows
• Linux
• MAC
• …

Что значит защищенный режим?

В отличие от реального режима, защищенный поддерживает 32-битные инструкции. Но вам об этом задумываться не стоит, так как нас не особо волнует процесс функционирования ОС.

Что такое Ассемблер?

Ассемблер преобразует передаваемые пользователем инструкции в машинный код.

Разве компилятор делает не то же самое?

На более высоком уровне да, но, фактически, внутри компилятора этим занимается именно ассемблер.

Почему компилятор не может генерировать машинный код напрямую?

Основная задача компилятора состоит в преобразовании инструкций пользователя в их промежуточный набор, называемый инструкциями ассемблера, после чего ассемблер преобразует их в соответствующий машинный код.

Зачем нужна ОС для написания кода загрузочного сектора?

Прямо сейчас я не хочу вдаваться в подробности и ограничусь пояснением в рамках материала текущей статьи. Как я говорил, для написания инструкций, которые поймет микропроцессор, нам нужен компилятор. Он, в свою очередь, разрабатывается в качестве утилиты ОС и используется через нее, соответственно.

Какую ОС можно использовать?

Так как я писал загрузочные программы под Ubuntu, то и вам для ознакомления с данным руководством порекомендую именно эту ОС.

Какой следует использовать компилятор?

Я писал загрузчики при помощи GNU GCC и демонстрировать компиляцию кода я буду на нем же. Как протестировать рукописный код для загрузочного сектора? Я представлю вам эмулятор архитектуры x86, который помогает дорабатывать код, не требуя постоянной перезагрузки компьютера при редактировании загрузочного сектора устройства.

Знакомство с микропроцессором

Прежде чем изучать программирование микропроцессора, нам необходимо разобрать использование регистров.

Что такое регистры?

Регистры подобны утилитам микропроцессора, служащим для временного хранения данных и управления ими согласно нашим потребностям. Предположим, пользователь задает операцию сложения 2 и 3, для чего компьютер сохраняет число 3 в одном регистре, а 2 в другом, после чего складывает содержимое этих регистров. В итоге ЦПУ помещает результат в еще один регистр, который и представляет нужный пользователю вывод. Регистры разделяются на четыре основных типа:

• регистры общего назначения;
• сегментные регистры;
• индексные регистры;
• регистры стека.

Я дам краткое пояснение по каждому типу.

Регистры общего назначения используются для хранения временных данных, необходимых программе в процессе выполнения. Каждый такой регистр имеет емксоть 16 бит или 2 байта.
• AX – регистр сумматора;
• BX – регистр базового адреса;
• CX – регистр-счетчик;
• DX – регистр данных.

Сегментные регистры: служат для представления микропроцессору адреса памяти. Здесь нужно знать два термина:
• Сегмент: независимый блок памяти, поддерживаемый аппаратно. Обычно обозначается начальным адресом.
• Смещение: указывает индекс относительно начала сегмента.

Пример: у нас есть байт, представляющий значение “X” и расположенный в 10-й позиции от начала блока памяти со стартовым адресом 0x7c00. В данной ситуации мы выразим сегмент как 0x7c00, а смещение как 10.
Абсолютным адресом тогда будет 0x7c00 + 10.

Здесь я хочу выделить четыре категории:
• CS – сегмент кода;
• SS – сегмент стека;
• DS – сегмент данных;
• ES – расширенный сегмент.

При этом нужно учитывать ограничения этих регистров, а именно невозможность прямого присваивания адреса. Вместо этого нам приходится копировать адрес сначала в регистры общего назначения, после чего снова копировать его уже в сегментные. Например, для решения задачи обнаружения байта “X” мы делаем следующее:

movw $0x07c0, %ax
movw %ax    , %ds
movw (0x0A) , %ax 

Здесь происходит:

• загрузка значения 0x07c0 * 16 в AX;
• загрузка содержимого AX в DS;
• установка 0x7c00 + 0x0a в AX.

Регистры стека:
• BP – базовый указатель;
• SP – указатель стека.

Индексные регистры:
• SI: регистр индекса источника.
• DI: регистр индекса получателя.
• AX: используется ЦПУ для арифметических операций.
• BX: может содержать адрес процедуры или переменной (это также могут SI, DI и BP) и использоваться для выполнения арифметических операций и перемещения данных.
• CX: выступает в роли счетчика цикла при повторении инструкций.
• DX: содержит старшие 16 бит произведения при умножении, а также задействуется при делении.
• CS: содержит базовый адрес всех выполняемых инструкций программы.
• SS: содержит базовый адрес стека.
• DS: содержит предустановленный адрес переменных.
• ES: содержит дополнительный базовый адрес переменных памяти.
• BP: содержит предполагаемое смещение из регистра SS. Часто используется подпрограммами для обнаружения переменных, переданных в стек вызывающей программой.
• SP: содержит смещение вершины стека.
• SI: используется в инструкциях перемещения строк. При этом на исходную строку указывает регистр SI.
• DI: выступает в роли места назначения для инструкций перемещения строк.

Что такое бит?

В вычислительных средах бит является наименьшей единицей данных, представляющей их в двоичном формате, где 1 = да, а 0 = нет.

Дополнительно о регистрах:

Ниже описано дальнейшее подразделение регистров:
• AX: первые 8 бит AX обозначаются как AL, последние 8 бит как AH.
• BX: первые 8 бит BX обозначаются как BL, последние 8 как как BH.
• CX: первые 8 бит CX обозначаются как CL, последние 8 бит как CH.
• DX: первые 8 бит DX обозначаются как DL, последние 8 бит как DH.

Как обращаться к функциям BIOS?

BIOS предоставляет ряд функций, позволяющих распределять приоритеты ЦПУ. Доступ к этим возможностям BIOS можно получить с помощью прерываний.

Что такое прерывания?

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

Какое прерывание будем использовать мы?

Прерывание INT 0x10.

Написание кода на Ассемблере

Какие типы данных доступны в GNU Assembler?

Типы данных определяют их характеристики и могут быть следующими:

• байт;
• слово;
• Int;
• ASCII;
• ASCIIZ.

Байт: состоит из восьми бит и считается наименьшей единицей хранения информации при программировании.
Слово: единица данных, состоящая из 16 бит.

Int: целочисленный тип данных, состоящий из 32 бит, которые могут быть представлены четырьмя байтами или двумя словами.
Прим. Справедливости ради, стоит отметить, что размер Int зависит от архитектуры и может составлять от 16 до 64 бит (а на некоторых системах даже 8 бит). То, очем говорит автор — это тип long. Подробнее о типах С можно прочесть по ссылке.

ASCII: представляет группу байтов без нулевого символа.

ASCIIZ: выражает группу байтов, завершающуюся нулевым символом.

Как генерировать код для реального режима в Ассемблере?

В процессе запуска ЦПУ в реальном режиме (16 бит) мы можем задействовать только встроенные функции BIOS. Я имею в виду, что с помощью этих функций можно написать собственный код загрузчика, поместить его в загрузочный сектор и выполнить загрузку. Давайте рассмотрим написание на Ассемблере небольшого фрагмента программы для генерации 16-битного кода ЦПУ через GNU Assembler.

Файл-образец: test.S

.code16                   #генерирует 16-битный код
.text                     #расположение исполняемого кода
     .globl _start;
_start:                   #точка входа
     . = _start + 510     #перемещение из позиции 0 к 510-му байту 
     .byte 0x55           #добавление сигнатуры загрузки
     .byte 0xaa           #добавление сигнатуры загрузки

Пояснения:

• .code16: это директива, отдаваемая ассемблеру для генерации не 32-, а 16-битного кода. Зачем это нужно? Ассемблер вы будете использовать через операционную систему, а код загрузчика будете писать с помощью компилятора. Но вы также наверняка помните, что ОС работает в защищенном 32-битном режиме. Поэтому, по умолчанию ассемблер в такой ОС будет производить 32-битный код, что не соответствует нашей задаче. Данная же директива исправляет этот нюанс, и мы получаем 16-битный код.
• .text: этот раздел содержит фактические машинные инструкции, составляющие вашу программу.
• .globl _start: .global <символ> делает символ видимым для компоновщика. При определении символа в подпрограмме его значение становится доступным для других связанных подпрограмм. Иначе говоря, символ получает атрибуты от символа с таким же именем, находящегося в другом файле, связанном с этой программой.
• _start: точка входа в основной код, а также предустановленная точка входа для компоновщика.
• = _start + 510: переход от начальной позиции к 510-му байту.
• .byte 0x55: первый байт, определяемый как часть сигнатуры загрузки (511-й байт).
• .byte 0xaa: последний байт, определяемый как часть сигнатуры загрузки (512-й байт).

Как скомпилировать программу ассемблера?

Сохраните код в файле test.S и введите в командной строке:

• as test.S -o test.o
• ld –Ttext 0x7c00 --oformat=binary test.o –o test.bin

Что означают эти команды?

• as test.S –o test.o: преобразует заданный код в промежуточную объектную программу, которая затем преобразуется уже в машинный код.
• --oformat=binary сообщает компоновщику, что выходной двоичный файл должен быть простым двоичным образом, т.е. не иметь кода запуска, связывания адресов и пр.
• –Ttext 0x7c00 сообщает компоновщику, что для вычисления абсолютного адреса нужно загрузить адрес “text” (сегмент кода) в 0x7c00.

Что такое сигнатура загрузки?

Давайте вспомним о загрузочном секторе, используемом BIOS для запуска системы, и подумаем, как BIOS узнает о наличии такого сектора на устройстве? Тут нужно пояснить, что состоит он из 512 байт, в которых для 510-го байта ожидается символ 0x55, а для 511-го символ 0xaa. Исходя из этого, BIOS проверяет соответствие двух последний байт загрузочного сектора этим значениям и либо продолжает загрузку, либо сообщает о ее невозможности. При помощи hex-редактора можно просматривать содержимое двоичного файла в более читабельном виде, и ниже в качестве примера я привел снимок этого файла.

Как скопировать исполняемый код на загрузочное устройство и протестировать его?

Чтобы создать образ для дискеты размером 1.4Мб, введите в командную строку следующее:
• dd if=/dev/zero of=floppy.img bs=512 count=2880

Чтобы скопировать этот код в загрузочный сектор файла образа, введите:
• dd if=test.bin of=floppy.img

Для проверки программы введите:
• bochs

Если bochs не установлен, тогда можно ввести следующее:
• sudo apt-get install bochs-x

Файл-образец: bochsrc.txt

megs: 32
#romimage: file=/usr/local/bochs/1.4.1/BIOS-bochs-latest, address=0xf0000
#vgaromimage: /usr/local/bochs/1.4.1/VGABIOS-elpin-2.40
floppya: 1_44=floppy.img, status=inserted
boot: a
log: bochsout.txt
mouse: enabled=0 

В результате должно отобразиться стандартное окно эмуляции bochs:

Просмотр:
Если теперь заглянуть в файл test.bin через hex-редактор, то вы увидите, что сигнатура загрузки находится после 510-го байта:

Пока что вы просто увидите сообщение “Booting from Floppy”, так как в коде мы еще ничего не прописали. Давайте рассмотрим пару других примеров создания кода на ассемблере.

Файл-образец: test2.S

.code16                    #генерирует 16-битный код
.text                      #расположение исполняемого кода
     .globl _start;
_start:                    #точка входа

     movb $'X' , %al       #выводимый символ
     movb $0x0e, %ah       #выводимый служебный код bios
     int  $0x10            #прерывание цпу

     . = _start + 510      #перемещение из позиции 0 к 510-му байту
     .byte 0x55            #добавление сигнатуры загрузки
     .byte 0xaa            #добавление сигнатуры загрузки

После ввода этого кода сохраните его в test2.S и выполните действия согласно прежней инструкции, изменив имя исходного файла. После компиляции, копирования кода в загрузочный сектор и выполнения bochs вы должны увидеть следующий экран, где теперь отображается прописанная нами в коде буква X.

Поздравляю, ваша первая программа в загрузочном секторе работает!

Просмотр:
В hex-редакторе вы увидите, что символ X находится во второй позиции от начального адреса.

Теперь давайте выведем на экран текст побуквенно.

Файл-образец: test3.S

.code16                  #генерирует 16-битный код
.text                    #расположение исполняемого кода
     .globl _start;

_start:                  #точка входа

     #выводит 'H' 
     movb $'H' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'e'
     movb $'e' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'l'
     movb $'l' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'l'
     movb $'l' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'o' 
     movb $'o' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит ','
     movb $',' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит ' '
     movb $' ' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'W'
     movb $'W' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит'o'
     movb $'o' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'r'
     movb $'r' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'l'
     movb $'l' , %al
     movb $0x0e, %ah
     int  $0x10

     #выводит 'd'
     movb $'d' , %al
     movb $0x0e, %ah
     int  $0x10

     . = _start + 510    #перемещение из позиции 0 к 510-му байту
     .byte 0x55            #добавление сигнатуры загрузки
     .byte 0xaa            #добавление сигнатуры загрузки

Сохраните файл как test3.S. После компиляции и всех сопутствующих действий перед вами отобразится следующий экран:

Просмотр:

Хорошо. Теперь давайте напишем программу, выводящую на экран фразу “Hello, World”.
При этом мы также определим функции и макросы, с помощью которых и будем выводить эту строку.

Файл-образец: test4.S

#генерирует 16-битный код
.code16
#расположение исполняемого кода
.text
.globl _start;
#точка входа загрузочного кода
_start:
      jmp _boot                           #переход к загрузочному коду
      welcome: .asciz "Hello, Worldnr"  #здесь мы определяем строку

     .macro mWriteString str              #макрос, вызывающий функцию вывода строки
          leaw  str, %si
          call .writeStringIn
     .endm

     #функция вывода строки
     .writeStringIn:
          lodsb
          orb  %al, %al
          jz   .writeStringOut
          movb $0x0e, %ah
          int  $0x10
          jmp  .writeStringIn
     .writeStringOut:
     ret

_boot:
     mWriteString welcome

     #перемещение от начала к 510-му байту и присоединение сигнатуры загрузки
     . = _start + 510
     .byte 0x55
     .byte 0xaa  

Сохраните файл как test4.S. Теперь после компиляции и всего за ней следующего вы увидите:

Отлично! Если вы поняли все проделанные мной действия и успешно создали аналогичную программу, то я вас поздравляю еще раз!

Просмотр:

Что такое функция?

Функция – это блок кода, имеющий имя и переиспользуемое свойство.

Что такое макрос?

Макрос – это фрагмент кода с присвоенным именем, на место использования которого подставляется содержимое этого макроса.

В чем синтаксическое отличие функции от макроса?

Для вызова функции используется следующий синтаксис:

• push <аргумент>
• call <имя функции>

А для макроса такой:

• macroname <аргумент>

И поскольку синтаксис вызова и применения макроса проще, чем функции, я предпочел использовать в основном коде именно его.

Написание кода в компиляторе С

Что такое C?

С – это язык программирования общего назначения, разработанный сотрудником Bell Labs Деннисом Ритчи в 1969-1973 годах.

Почему мы используем именно этот язык? Причина в том, что создаваемые на нем программы, как правило, не велики и отличаются высокой скоростью. Помимо этого, он включает низкоуровневые возможности, которые обычно доступны только в ассемблере или машинном языке. Ко всему прочему, С также является структурированным.

Что нужно для написания кода на С?

Мы будем использовать компилятор GNU C под названием GCC и разберем написание в нем программы на примере.

Файл-образец: test.c

__asm__(".code16n");
__asm__("jmpl $0x0000, $mainn");

void main() {
} 

Файл: test.ld

ENTRY(main);
SECTIONS
{
    . = 0x7C00;
    .text : AT(0x7C00)
    {
        *(.text);
    }
    .sig : AT(0x7DFE)
    {
        SHORT(0xaa55);
    }
} 

Для компиляции программы введите в командной строке:

• gcc -c -g -Os -march=i686 -ffreestanding -Wall -Werror test.c -o test.o
• ld -static -Ttest.ld -nostdlib --nmagic -o test.elf test.o
• objcopy -O binary test.elf test.bin

Что значат эти команды?

Первая преобразует код C в промежуточную объектную программу, которая в последствии преобразуется в машинный код.
• gcc -c -g -Os -march=i686 -ffreestanding -Wall -Werror test.c -o test.o:

Что значат эти команды?

• -c: используется для компиляции исходного кода без линковки.
• -g: генерирует отладочную информацию для отладчика GDB.
• -Os: оптимизация размера кода.
• -march: генерирует код для конкретной архитектуры ЦПУ (в нашем случае i686).
• -ffreestanding: в среде отдельных программ может отсутствовать стандартная библиотека, а инструкции запуска программы не обязательно располагаются в “main”.
• -Wall: активирует все предупреждающие сообщения компилятора. Рекомендуется всегда использовать эту опцию.
• -Werror: активирует трактовку предупреждений как ошибок.
• test.c: имя входного исходного файла.
• -o: генерация объектного кода.
• test.o: имя выходного файла объектного кода.

С помощью всей этой комбинации флагов мы генерируем объектный код, помогающий нам в обнаружении ошибок и предупреждений, а также создаем более эффективный код для данного типа ЦПУ. Если не указать march=i686, будет сгенерирован код для используемой вами машины. В связи с этим нужно указывать, для какого именно типа ЦПУ он создается.

• ld -static -Ttest.ld -nostdlib --nmagic test.elf -o test.o:
Эта команда вызывает компоновщик из командной строки, и ниже я поясню, как именно мы его используем.

Что значат эти флаги?

• -static: не линковать с общими библиотеками.
• -Ttest.ld: разрешить компоновщику следовать командам из его скрипта.
• -nostdlib: разрешить компоновщику генерировать код, не линкуя функции запуска стандартной библиотеки C.
• --nmagic: разрешить компоновщику генерировать код без фрагментов _start_SECTION и _stop_SECTION.
• test.elf: имя выходного файла (соответствующий платформе формат хранения исполняемых файлов. Windows: PE, Linux: ELF)
• -o: генерация объектного кода.
• test.o: имя входного файла объектного кода.

Что такое компоновщик?

Он выполняет последний этап компиляции. ld (компоновщик) получает один или более объектных файлов либо библиотек и совмещает их в один, как правило, исполняемый файл. В ходе этого процесса он обрабатывает ссылки на внешние символы, присваивает конечные адреса процедурам/функциям и переменным, а также корректирует код и данные для отражения актуальных адресов.
Не забывайте, что мы не используем в коде стандартные библиотеки и сложные функции.

• objcopy -O binary test.elf test.bin
Эта команда служит для генерации независимого от платформы кода. Обратите внимание, что в Linux исполняемые файлы хранятся не так, как в Windows. В каждой системе свой способ хранения, но мы создаем всего-навсего небольшой загрузочный код, который на данный момент не зависит от ОС.

Зачем в программе C использовать инструкции ассемблера?

В реальном режиме к функциям BIOS можно легко обратиться через прерывания при помощи именно инструкций ассемблера.

Как скопировать код на загрузочное устройство и проверить его?

Чтобы создать образ для дискеты размером 1.4Мб, введите в командную строку:

• dd if=/dev/zero of=floppy.img bs=512 count=2880
Чтобы скопировать код в загрузочный сектор файла образа, введите:
• dd if=test.bin of=floppy.img
Для проверки программы введите:
• bochs

Должно отобразиться стандартное окно эмуляции:

Что мы видим: как и в первом нашем примере, пока что здесь отображается только сообщение “Booting from Floppy”.

Для вложения инструкция ассемблера в программу C мы используем ключевое слово __asm__.
• Дополнительно мы задействуем __volatile__, указывая компилятору, что код нужно оставить как есть, без изменений.

Такой способ вложения называется встраивание ассемблерного кода.
Рассмотрим еще несколько примеров написания с помощью компилятора.

Пишем программу для вывода на экран ‘X’

Файл-образец: test2.c

__asm__(".code16n");
__asm__("jmpl $0x0000, $mainn");

void main() {
     __asm__ __volatile__ ("movb $'X'  , %aln");
     __asm__ __volatile__ ("movb $0x0e, %ahn");
     __asm__ __volatile__ ("int $0x10n");
}

Написав код, сохраните файл как test2.c и скомпилируйте его согласно все тем же инструкциям, изменив исходное имя. После компиляции, копирования кода в загрузочный сектор и выполнения команды bochs вы снова увидите экран, где отображается буква X:

Теперь напишем код для показа фразы “Hello, World”

Для вывода данной строки мы также определим функции и макросы.

Файл-образец: test3.c

/* генерирует 16-битный код */
__asm__(".code16n");
/* переходит к точке входа загрузочного кода */
__asm__("jmpl $0x0000, $mainn");

void main() {
     /* выводит 'H' */
     __asm__ __volatile__("movb $'H' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'e' */
     __asm__ __volatile__("movb $'e' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'l' */
     __asm__ __volatile__("movb $'l' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'l' */
     __asm__ __volatile__("movb $'l' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'o' */
     __asm__ __volatile__("movb $'o' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит ',' */
     __asm__ __volatile__("movb $',' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит ' ' */
     __asm__ __volatile__("movb $' ' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'W' */
     __asm__ __volatile__("movb $'W' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'o' */
     __asm__ __volatile__("movb $'o' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'r' */
     __asm__ __volatile__("movb $'r' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'l' */
     __asm__ __volatile__("movb $'l' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");

     /* выводит 'd' */
     __asm__ __volatile__("movb $'d' , %aln");
     __asm__ __volatile__("movb $0x0e, %ahn");
     __asm__ __volatile__("int  $0x10n");
}

Сохраните этот код в файле test3.c и следуйте уже знакомым вам инструкциям, изменив имя исходного файла и скопировав скомпилированный код в загрузочный сектор дискеты. Теперь на этапе проверки должна отобразиться надпись «Hello, World»:

Напишем на C программу для вывода строки “Hello, World”

При этом мы определим функцию, выводящую эту строку на экран.

Файл-образец: test4.c

/*генерирует 16-битный код*/
__asm__(".code16n");
/*переход к точке входа в загрузочный код*/
__asm__("jmpl $0x0000, $mainn");

/* пользовательская функция для вывода серии знаков, завершаемых нулевым символом*/
void printString(const char* pStr) {
     while(*pStr) {
          __asm__ __volatile__ (
               "int $0x10" : : "a"(0x0e00 | *pStr), "b"(0x0007)
          );
          ++pStr;
     }
}

void main() {
     /* вызов функции <code>printString</code> со строкой в качестве аргумента*/
     printString("Hello, World");
} 

Сохраните этот код в файле test4.c и снова проследуйте всем инструкциям компиляции и загрузки, в результате чего на экране должно отобразиться следующее:

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

Далее мы перейдем к написанию циклов и их использованию в функциях, а также познакомимся с другими службами BIOS.

Мини-проект отображения прямоугольников

Файл-образец: test5.c

/* генерирует 16-битный код                                                 */
__asm__(".code16n");
/* переход к главной функции или программному коду                                */
__asm__("jmpl $0x0000, $mainn");

#define MAX_COLS     320 /* количество столбцов экрана               */
#define MAX_ROWS     200 /* количество строк экрана                  */

/* функция вывода строки*/
/* input ah = 0x0e*/
/* input al = <выводимый символ>*/
/* прерывание: 0x10*/
/* мы используем прерывание 0x10 с кодом функции 0x0e для вывода байта из al*/
/* эта функция получает в качестве аргумента строку и выводит символ за символом, пока не достигнет нуля*/

void printString(const char* pStr) {
     while(*pStr) {
          __asm__ __volatile__ (
               "int $0x10" : : "a"(0x0e00 | *pStr), "b"(0x0007)
          );
          ++pStr;
     }
}

/* функция, получающая сигнал о нажатии клавиши на клавиатуре */
/* input ah = 0x00*/
/* input al = 0x00*/
/* прерывание: 0x10*/
/* эта функция регистрирует нажатие пользователем клавиши для продолжения выполнения */
void getch() {
     __asm__ __volatile__ (
          "xorw %ax, %axn"
          "int $0x16n"
     );
}

/* функция вывода на экран цветного пикселя в заданном столбце и строке */
/* входной ah = 0x0c*/
/* входной al = нужный цвет*/
/* входной cx = столбец*/
/* входной dx = строка*/
/* прерывание: 0x10*/
void drawPixel(unsigned char color, int col, int row) {
     __asm__ __volatile__ (
          "int $0x10" : : "a"(0x0c00 | color), "c"(col), "d"(row)
     );
}

/* функции очистки экрана и установки видео-режима 320x200 пикселей*/
/* функция для очистки экрана */
/* входной ah = 0x00 */
/* входной al = 0x03 */
/* прерывание = 0x10 */
/* функция для установки видео режима */
/* входной ah = 0x00 */
/* входной al = 0x13 */
/* прерывание = 0x10 */
void initEnvironment() {
     /* очистка экрана */
     __asm__ __volatile__ (
          "int $0x10" : : "a"(0x03)
     );
     __asm__ __volatile__ (
          "int $0x10" : : "a"(0x0013)
     );
}

/* функция вывода прямоугольников в порядке уменьшения их размера */
/* я выбрал следующую последовательность отрисовки: */
/* из левого верхнего угла в левый нижний, затем в правый нижний, оттуда в верхний правый и в завершении в верхний левый край */
void initGraphics() {
     int i = 0, j = 0;
     int m = 0;
     int cnt1 = 0, cnt2 =0;
     unsigned char color = 10;

     for(;;) {
          if(m < (MAX_ROWS - m)) {
               ++cnt1;
          }
          if(m < (MAX_COLS - m - 3)) {
               ++cnt2;
          }

          if(cnt1 != cnt2) {
               cnt1  = 0;
               cnt2  = 0;
               m     = 0;
               if(++color > 255) color= 0;
          }

          /* верхний левый -> левый нижний */
          j = 0;
          for(i = m; i < MAX_ROWS - m; ++i) {
               drawPixel(color, j+m, i);
          }
          /* левый нижний -> правый нижний */
          for(j = m; j < MAX_COLS - m; ++j) {
               drawPixel(color, j, i);
          }

          /* правый нижний -> правый верхний */
          for(i = MAX_ROWS - m - 1 ; i >= m; --i) {
               drawPixel(color, MAX_COLS - m - 1, i);
          }
          /* правый верхний -> левый верхний */
          for(j = MAX_COLS - m - 1; j >= m; --j) {
               drawPixel(color, j, m);
          }
          m += 6;
          if(++color > 255)  color = 0;
     }
}

/* эта функция является загрузочным кодом и вызывает следующие функции: */
/* вывод на экран сообщения, предлагающего пользователю нажать любую клавишу для продолжения. После нажатия клавиши происходит отрисовка прямоугольников в порядке убывания их размера */
void main() {
     printString("Now in bootloader...hit a key to continuenr");
     getch();
     initEnvironment();
     initGraphics();
}

Сохраните все это в файле test5.c и следуйте все тем же инструкциям компиляции с последующим копированием кода в загрузочный сектор дискеты.

Теперь в качестве результата вы увидите:

Нажмите любую клавишу.

Просмотр:
Если внимательно рассмотреть содержимое исполняемого файла, то можно заметить, что в нем практически закончилось свободное пространство. Поскольку размер загрузочного сектора ограничен 512 байтами, мы смогли вместить только несколько функций, а именно выполнить инициализацию среды и вывод цветных прямоугольников. Вот снимок содержимого файла:

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

Примечание переводчика: описание автором функционирования регистров и некоторых других технических деталей, по всей видимости, требует уточнения. В связи с этим по вызывающим сомнение вопросам рекомендуется обратиться к более авторитетным литературным источникам.

1
2
3
4
5

%define SETUP_SEG 0x07e0
%define SETUP_SECTS 10
 
%define KERNEL_SEG      0x1000
%define KERNEL_SECTS 1000

1
2
3
4

section .text
        BITS    16
 
        org     0x7c00

1
2
3
4
5
6
7

entry_point: mov     ax, cs
        cli
        mov     ss, ax
        mov     sp, entry_point
        sti
 
        mov     ds, ax

1
2
3
4
5
6
7
8
9
10
11

        ; Сохpаняем фоpму куpсоpа
        mov     ah, 3
        xor     bh, bh
        int     0x10
 
        push    cx
 
        ; отключаем куpсоp
        mov     ah, 1
        mov     ch, 0x20
        int     10h

1
2
3
4
5
6
7
8
9
10
11
12
13
14

        ; Загpужаем setup
        mov     ax, SETUP_SEG
        mov     es, ax
 
        mov     ax, 1
        mov     cx, SETUP_SECTS
 
        mov     si, load_setup_msg
        call    load_block
 
        call    outstring
 
        mov     si, complete_msg
        call    outstring

1
2
3
4
5
6
7
8
9
10
11
12
13
14

       ; загpужаем ядpо.
        mov     ax, KERNEL_SEG
        mov     es, ax
 
        mov     ax, 1 + SETUP_SECTS
        mov     cx, KERNEL_SECTS
 
        mov     si, load_kernel_msg
        call    load_block
 
        call    outstring
 
        mov     si, complete_msg
        call    outstring

1
2
3
4

        ; Восстанавливаем куpсоp
        pop     cx
        mov     ah, 1
        int     0x10

1
2

        ; Пеpедаем упpавление на setup
        jmp     SETUP_SEG:0

1
2
3
4
5

; Загрузка блока
; cx - количество сектоpов
; ax - начальный сектоp
; es - указатедь на память
; si - loading message

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

load_block:
        mov     di, cx ; сохpаняем количество блоков
 
 .loading:
        xor     bx, bx
        call    load_sector
        inc     ax
        mov     bx, es
        add     bx, 0x20
        mov     es, bx
 
        ; Выводим сообщение о загpузке.
        call    outstring
 
        push    ax
 
        ; Выводим пpоценты
        ; ((di - cx) / di) * 100
        mov     ax, di
        sub     ax, cx
        mov     bx, 100
        mul     bx
        div     di
 
        call    outdec
 
        push    si
        mov     si, persent_msg
        call    outstring
        pop     si
 
        pop     ax
 
        loop    .loading
 
        ret

1
2
3

; Загрузка сектора
; ax - номеp сектоpа (0...max (2880))
; es:bx - адpес для pазмещения сектоpа.

1
2
3
4
5
6
7

load_sector: push ax
 push cx
 cwd
 mov cx, 18 ; SectPerTrack
 div cx 
 mov cx, dx
 inc cx ; количество секторов

1

        xor     dx, dx  ; dl - диск - 0!

1
2

       shr     ax, 1
        rcl     dh, 1 ; номер головки

1
2
3

        mov     ch, al
        shl     ah, 4
        or      cl, ah ; количество доpожек

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

 .rept:
        mov     ax, 0x201
        int     0x13
 
        jnc     .read_ok
 
        push    si
        mov     si, read_error
        call    outstring
 
        movzx   ax, ah
        call    outdec
 
        mov     si, crlf
        call    outstring
 
        xor     dl, dl
        xor     ah, ah
        int     0x13
 
        pop     si
 
        jmp     short .rept

1
2
3
4
5

.read_ok:
 
        pop     cx
        pop     ax
        ret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

; Вывод строки.
; ds:si - стpока.
 
outstring:
        push    ax
        push    si
 
        mov     ah, 0eh
 
        jmp     short .out
 .loop:
        int     10h
 .out:
        lodsb
        or      al, al
        jnz     .loop
 
        pop     si
        pop     ax
        ret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

; Вывод десятичных чисел от 0 до 99
; ax - число!
outdec:
        push    ax
        push    si
        mov     bl, 10
        div     bl
        cmp     al, 10
        jnc     .overflow
        add     ax, '00'
        push    ax
        mov     ah, 0eh
        int     0x10
        pop     ax
        mov     al, ah
        mov     ah, 0eh
        int     0x10
        jmp     short .exit
 .overflow:
        mov     si, overflow_msg
        call    outstring
 .exit:
        pop     si
        pop     ax
        ret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

load_setup_msg:
        db      'Setup loading: ', 0
 
load_kernel_msg:
        db      'Kernel loading: ', 0
 
complete_msg:
        db      'complete.'
 
crlf:
        db      0ah, 0dh, 0
 
persent_msg:
        db      '%', 0dh, 0
 
overflow_msg:
        db      '##', 0
 
read_error:
        db      0ah, 0dh
        db      'Read error #', 0
 
        TIMES   510-($-$$) db 0

1
2
3
4
5
6
7

load_sector:
        push    ax
        push    cx
        mov     cl, 18
        div     cl
        mov     cx, dx
        inc     cx

1
2
3
4
5
6
7
8
9
10
11
12
13
14

struct FAT_Parameter_block {
  u_int16       Sector_Size;
  u_int8        Sectors_Per_Cluster;
  u_int16       Reserved_Sectors;
  u_int8        FAT_Count;
  u_int16       Root_Entries;
  u_int16       Total_Sectors;
  u_int8        Media_Descriptor;
  u_int16       Sectors_Per_FAT;
  u_int16       Sectors_Per_Track;
  u_int16       Heads;
  u_int32       Hidden_sectors;
  u_int32       Big_Total_Sectors;
};

1
2
3
4
5
6
7
8
9
10

struct FAT_Directory_entry {
  char          Name[8];
  char          Extension[3];
  u_int16       File_Attribute;
  char          Reserved[10];
  u_int16       Time;
  u_int16       Date;
  u_int16       Cluster_No;
  u_int32       Size;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

struct ext2_super_block {
  u_int32  s_inodes_count;
  u_int32  s_blocks_count;
  u_int32  s_r_blocks_count;
  u_int32  s_free_blocks_count;
  u_int32  s_free_inodes_count;
  u_int32  s_first_data_block;
  u_int32  s_log_block_size;
  int32    s_log_frag_size;
  u_int32  s_blocks_per_group;
  u_int32  s_frags_per_group;
  u_int32  s_inodes_per_group;
  u_int32  s_mtime;
  u_int32  s_wtime;
  u_int16  s_mnt_count;
  u_int16  s_max_mnt_count;
  u_int16  s_magic;
  u_int16  s_state;
  u_int16  s_errors;
  u_int16  s_pad;
  u_int32  s_lastcheck;
  u_int32  s_checkinterval;
  u_int32  s_reserved[238];
};

1
2
3
4
5
6
7
8
9
10

struct ext2_group_desc {
  u_int32  bg_block_bitmap;
  u_int32  bg_inode_bitmap;
  u_int32  bg_inode_table;
  u_int16  bg_free_blocks_count;
  u_int16  bg_free_inodes_count;
  u_int16  bg_used_dirs_count;
  u_int16  bg_pad;
  u_int32  bg_reserved[3];
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct ext2_inode {
  u_int16  i_mode;
  u_int16  i_uid;
  u_int32  i_size;
  u_int32  i_atime;
  u_int32  i_ctime;
  u_int32  i_mtime;
  u_int32  i_dtime;
  u_int16  i_gid;
  u_int16  i_links_count;
  u_int32  i_blocks;
  u_int32  i_flags;
  u_int32  i_reserved1;
  u_int32  i_block[14];
  u_int32  i_version;
  u_int32  i_file_acl;
  u_int32  i_dir_acl;
  u_int32  i_faddr;
  u_int8   i_frag;
  u_int8   i_fsize;
  u_int16  i_pad1;
  u_int32  i_reserved2[2];
};

1
2
3
4
5

        mov     ax, 0x7e0
        mov     es, ax
        mov     ax, 1
        mov     cx, 5
        call    load_block

1
2
3
4
5
6
7
8
9
10
11

sb      equ     0x8000
ext2_init:
        pusha
        cmp     word [sb + ext2_sb.magic], 0xef53
        jz      short .right
        mov     si, bad_sb
        call    outstring
        popa
        stc
        ret
bad_sb: db 'Bad ext2 super block!', 0ah, 0dh, 0

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

.right:
        mov     ax, 1024
        mov     cl, [sb + ext2_sb.log_block_size]
        shl     ax, cl
        mov     [block_size], al        ; Размер блока в байтах
        shr     ax, 2
        mov     [block_dword_size], ax  ; Размер блока в dword
        shr     ax, 2
        mov     [block_seg_size], ax    ; Размер блока в параграфах
        shr     ax, 5
        mov     [block_sect_size], ax   ; Размер блока в секторах
        popa
        clc
        ret
block_size:             dw 1024
block_dword_size:       dw  256
block_seg_size:         dw 64
block_sect_size:        dw 2

1
2
3
4
5
6
7
8
9
10

ext2_load_block:
        pusha
        mov     cx, [block_sect_size]
        mul     cx
        call    load_block
        mov     ax, es
        add     ax, [block_seg_size]
        mov     es, ax ; смещаем es
        popa
        ret

1
2
3
4
5
6
7

ext2_get_inode:
        pusha
        push    es
 
        dec     ax
        xor     dx, dx
        div     word [sb + ext2_sb.inodes_per_group]

1
2
3

        shl     ax, gd_bit_size
        mov     bx, ax
        mov     bx, [gd + bx + ext2_gd.inode_table]

1
2

       mov     ax, dx
        shl     ax, inode_bit_size

1
2
3

        xor     dx, dx
        div     word [block_size]
        add     ax, bx

1
2
3

        mov     bx, tmp_block >> 4
        mov     es, bx
        call    ext2_load_block

1
2
3
4
5
6
7

        push    ds
        pop     es
        mov     si, dx
        add     si, tmp_block
        mov     di, inode
        mov     cx, ext2_i_size >> 1
        rep     movsw

1
2
3

        pop     es
        popa
        ret

1
2
3
4
5
6
7
8

ext2_load_inode:
        pusha
        xor     ax, ax
        mov     si, inode + ext2_i.block
        mov     cx, EXT2_NDIR_BLOCKS
        call    dir_blocks
        cmp     ax, [inode + ext2_i.blocks]
        jz      short .exit

1
2
3
4

        mov     cx, 1
        call    idir_blocks
        cmp     ax, [inode + ext2_i.blocks]
        jz      short .exit

1
2
3
4

        mov     cx, 1
        call    ddir_blocks
        cmp     ax, [inode + ext2_i.blocks]
        jz      short .exit

1
2
3
4
5
6
7
8
9
10
11

        push    ax
        push    es
        mov     ax, tmp3_block >> 4
        mov     es, ax
        lodsw
        call    ext2_load_block
        pop     es
        pop     ax
        mov     si, tmp3_block
        mov     cx, [block_dword_size]
        call    ddir_blocks

1
2
3

 .exit:
        popa
        ret

1
2
3
4
5
6
7
8
9
10
11
12
13

dir_blocks:
 .repeat:
        push    ax
        lodsw
        call    ext2_load_block
        add     si, 2
        pop     ax
        inc     ax
        cmp     ax, [inode + ext2_i.blocks]
        jz      short .exit
        loop    .repeat
 .exit:
 ret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

idir_blocks:
 .repeat:
        push    ax
        push    es
        mov     ax, tmp_block >> 4
        mov     es, ax
        lodsw
        call    ext2_load_block
        add     si, 2
        pop     es
        pop     ax
        push    si
        push    cx
 
        mov     si, tmp_block
        mov     cx, [block_dword_size]
        call    dir_blocks
 
        pop     cx
        pop     si
 
        cmp     ax, [inode + ext2_i.blocks]
        jz      short .exit
 
        loop    .repeat
 .exit:
        ret

1
2
3
4
5

ext2_load_file:
        pusha
 
        cmp     byte [si], '/'
        jnz     short .error_exit

1
2

       mov     ax, INODE_ROOT ; root_inode
        call    ext2_get_inode

1
2
3
4
5
6

 .cut_slash:
        cmp     byte [si], '/'
        jnz     short .by_inode
 
        inc     si
        jmp     short .cut_slash

1
2
3
4

 .by_inode:
        push    es
        call    ext2_load_inode
        pop     es

1
2
3
4

        mov     ax, [inode + ext2_i.mode]
        and     ax, IMODE_MASK
        cmp     ax, IMODE_REG
        jnz     short .noreg_file

1
2

        cmp     byte [si], 0
        jnz     short .error_exit

1
2
3

 .ok_exit:
        clc
        jmp     short .exit

1
2
3

 .noreg_file:
        cmp     ax, IMODE_DIR
        jnz     short .error_exit

1
2

        mov     dx, [inode + ext2_i.size]
        xor     bx, bx

1
2
3
4
5
6
7
8
9

 .walk_dir:
        lea     di, [es:bx + ext2_de.name]
        mov     cx, [es:bx + ext2_de.name_len]  ; длина имени
        push    si
        repe    cmpsb
        mov     al, [si]
        pop     si
        test    cx, cx
        jnz     short .notfind

1
2
3
4

        cmp     al, '/'
        jz      short .normal_path
        test    al, al
        jnz     short .notfind

1
2
3

 .normal_path:
        mov     ax, [es:bx + ext2_de.inode]
        call    ext2_get_inode

1
2
3
4

        add     si, [es:bx + ext2_de.name_len]
        cmp     byte [si], '/'
        jz      short .cut_slash
        jmp     short .by_inode

1
2
3
4
5

 .notfind:
        sub     dx, [es:bx + ext2_de.rec_len]
        add     bx, [es:bx + ext2_de.rec_len]
        test    dx, dx
        jnz     short .walk_dir

1
2
3
4

 .error_exit:
        mov     si, bad_dir
        call    outstring
        stc

1
2
3

 .exit:
        popa
        ret

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

#define EI_NIDENT 16
 
struct elf32_hdr {
  unsigned char e_ident[EI_NIDENT];
  Elf32_Half e_type;
  Elf32_Half e_machine;
  Elf32_Word e_version;
  Elf32_Addr e_entry;  /* Entry point */
  Elf32_Off e_phoff;
  Elf32_Off e_shoff;
  Elf32_Word e_flags;
  Elf32_Half e_ehsize;
  Elf32_Half e_phentsize;
  Elf32_Half e_phnum;
  Elf32_Half e_shentsize;
  Elf32_Half e_shnum;
  Elf32_Half e_shstrndx;
};

1
2
3
4
5
6
7

struct {
  unsigned char ei_magic[4];
  unsigned char ei_class;
  unsigned char ei_data;
  unsigned char ei_version;
  unsigned char ei_pad[9];
}

1
2
3
4
5
6
7
8
9
10

struct elf32_phdr {
  Elf32_Word p_type;
  Elf32_Off p_offset;
  Elf32_Addr p_vaddr;
  Elf32_Addr p_paddr;
  Elf32_Word p_filesz;
  Elf32_Word p_memsz;
  Elf32_Word p_flags;
  Elf32_Word p_align;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

{
  struct elf32_hdr *EH = (struct elf32_hdr *)bin;
  struct elf32_phdr *EPH;
 
  if (EH->e_ident[0] != 0x7f ||         // Контролируем MAGIC
      EH->e_ident[1] != 'E' ||
      EH->e_ident[2] != 'L' ||
      EH->e_ident[3] != 'F' ||
      EH->e_ident[4] != ELFCLASS32 ||   // Контролируем класс
      EH->e_ident[5] != ELFDATA2LSB ||  // порядок байт
      EH->e_ident[6] != EV_CURRENT ||   // версию
      EH->e_type != ET_EXEC ||          // тип
      EH->e_machine != EM_386 ||        // платформу
      EH->e_version != EV_CURRENT)      // и снова версию, на всякий случай
     return ELF_WRONG;
 
  EPH = (struct elf32_phdr *)(bin + EH->e_phoff);
 
  while (EH->e_phnum--) {
        if (EPH->p_type == PT_LOAD)
           memcpy (EPH->p_vaddr, bin + EPH->p_offset, EPH->p_filesz);
 
        EPH = (struct elf32_phdr *)((unsigned char *)EPH + EH->e_phentsize));
  }
 
  return ELF_OK;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

struct pe_hdr {
  unsigned long  pe_sign;
  unsigned short pe_cputype;
  unsigned short pe_objnum;
  unsigned long  pe_time;
  unsigned long  pe_cofftbl_off;
  unsigned long  pe_cofftbl_size;
  unsigned short pe_nthdr_size;
  unsigned short pe_flags;
  unsigned short pe_magic;
  unsigned short pe_link_ver;
  unsigned long  pe_code_size;
  unsigned long  pe_idata_size;
  unsigned long  pe_udata_size;
  unsigned long  pe_entry;
  unsigned long  pe_code_base;
  unsigned long  pe_data_base;
  unsigned long  pe_image_base;
  unsigned long  pe_obj_align;
  unsigned long  pe_file_align;
 
  // ... ну и еще много всякого, неважного.
};

1
2
3
4
5
6
7
8
9

struct pe_ohdr {
  unsigned char o_name[8];
  unsigned long o_vsize;
  unsigned long o_vaddr;
  unsigned long o_psize;
  unsigned long o_poff;
  unsigned char o_reserved[12];
  unsigned long o_flags;
};

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

int LoadPE (unsigned char *bin)
{
  struct elf32_hdr *PH = (struct pe_hdr *)
                (bin + *((unsigned long *)&bin[0x3c]));
// Конечно комбинация не из понятных... просто берем dword по смещению 0x3c
// И вычисляем адрес PE заголовка в образе файла
  struct elf32_phdr *POH;
 
  if (PH == NULL ||              // Контролируем указатель
      PH->pe_sign != 0x4550 ||   // сигнатура PE {'P', 'E', 0, 0}
      PH->pe_cputype != 0x14c || // i386
      (PH->pe_flags & 2) == 0)     // файл нельзя запускать!
     return PE_WRONG;
 
  POH = (struct pe_ohdr *)((unsigned char *)PH + 0xf8);
 
  while (PH->pe_obj_num--) {
        if ((POH->p_flags & 0x60) != 0)
           // либо код либо инициализированные данные
           memcpy (PE->pe_image_base + POH->o_vaddr,
                        bin + POH->o_poff, POH->o_psize);
 
        POH = (struct pe_ohdr *)((unsigned char *)POH +
                                        sizeof (struct pe_ohdr));
  }
 
  return PE_OK;
}

4

Что вас здесь ждёт

Если вы так же любопытны, как я, вы наверняка задумывались о том, как работают операционные системы. Здесь я расскажу о некоторых исследованиях и экспериментах, которые я провёл, чтобы лучше понять, как работают вычислительные и операционные системы. После прочтения вы создадите свою загрузочную программу, которая будет работать в любом приложении виртуальных машин, например в Virtual Box.

Важное замечание

Эта статья не предназначена для того, чтобы объяснить работу загрузчика во всей его сложности. Этот пример  —  отправная точка для x86 архитектуры. Для понимания этой статьи требуется базовое знание микропроцессоров и программирования.

Что такое загрузчик?

Простыми словами загрузчик  —  это часть программы, загружаемая в рабочую память компьютера после загрузки.

После нажатия кнопки Пуск компьютеру предстоит многое сделать. Запускается и выполняет свою работу прошивка, называемая BIOS (базовая система ввода-вывода). После этого BIOS передаёт управление загрузчику, установленному на любом доступном носителе: USB, жёстком диске, CD и т.д. BIOS последовательно просматривает все носители, проверяя уникальную подпись, которую также называют записью загрузки. Когда она найдена и загружена в память компьютера, начинает работать процессор. Если быть более точным, эта запись располагается по адресу 0x7C00. Сохраните его, он нужен для написания загрузчика.

Работа внутри первого сектора всего с 512 байтами.

Как упоминалось выше, в процессе инициализации BIOS ищет в первом секторе загрузочного устройства уникальную подпись. Её значение равно 0xAA55 и должно находиться в последних двух байтах первого сектора. И хотя все 512 байт доступны в главной загрузочной записи, мы не можем использовать их все: мы должны вычесть схему и подпись таблицы раздела диска и подпись. Останется только 440 байт. Маловато. Но вы можете решить эту проблему, написав код для загрузки данных из других секторов в памяти.

Шаги инициализации в упрощённом виде

• BIOS загружает компьютеры и их периферийные устройства.
• BIOS ищет загрузочные устройства.
• Когда BIOS находит подпись 0xAA55 в MBR, он загружает этот сектор в память в позицию 0x7C00 и передаёт управление этой точке входа, то есть начинает выполнение инструкций с точки в памяти 0x7C00.

Пишем код

Код загрузчика на ассемблере:

bits 16 

org 0x7c00 

boot:

    mov si, message 

    mov ah,0x0e

.loop:

    lodsb

    or al,al 

    jz halt  

    int 0x10

    jmp .loop

halt:

    cli

    hlt

message: db "Hey! This code is my boot loader operating.",0


times 510 - ($-$$) db 0 

dw 0xaa55

Ассемблер необходимо скомпилировать в машинный код. Обратите внимание, что 512 в шестнадцатеричной системе  —  это 0x200, а последние два байта  —  0x55 и 0xAA. Он инвертирован по сравнению с кодом ассемблера выше, что связано с системой порядка хранения, называемой порядком следования байтов. Например, в big-endian системе два байта, требуемых для шестнадцатеричного числа 0x55AA, будут храниться как 0x55AA (если 55 хранится по адресу 0x1FE, AA будет храниться 0x1FF). В little-endian системе это число будет храниться как 0xAA55 (AA по адресу 0x1FE, 55 в 0x1FF).

0000000 be 10 7c b4 0e ac 08 c0 74 04 cd 10 eb f7 fa f4

0000010 48 65 79 21 20 54 68 69 73 20 63 6f 64 65 20 69

0000020 73 20 6d 79 20 62 6f 6f 74 20 6c 6f 61 64 65 72

0000030 20 6f 70 65 72 61 74 69 6e 67 2e 00 00 00 00 00

0000040 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00

*

00001f0 00 00 00 00 00 00 00 00 00 00 00 00 00 00 55 aa

0000200

Машинный код после компиляции NASM

Как работает этот код

Я объясню этот код построчно в случае если вам не знаком ассемблер:

1. Если укажем целевой режим процессора, директива BITS укажет, где NASM следует сгенерировать код, предназначенный для работы на процессоре, поддерживающем 16-битный, 32-битный или 64-битный режим. Синтаксис  —  BITS XX, где XX это 16, 32 или 64.

2. Если укажем адрес начала программы в бинарном файла, директива ORG укажет начальный адрес, по которому NASM будет считать начало программы при её загрузке в память. Когда этот код переводится в машинный, компилятор и компоновщик определяют и организуют все структуры данных, необходимые программе. Для этой цели будет использован начальный адрес.

3. Это просто ярлык. Когда он определён в коде, то ссылается на позицию в памяти, которую вы можете указать. Он используется вместе с командами условного перехода для контроля потока приложения.

После разбора четвёртой строки нам необходимо описать концепцию регистров:

Регистр процессора  —  блок ячеек памяти, образующий сверхбыструю оперативную память (СОЗУ) внутри процессора. Используется самим процессором и большей частью недоступен программисту: например, при выборке из памяти очередной команды она помещается в регистр команд, к которому программист обратиться не может. Википедия

4. Назначение данных с помощью инструкции MOV, которая используется для перемещения данных. В данном случае мы перемещаем значение адреса в памяти ярлыка сообщения в регистр SI, который укажет на текст “Hey! This code is my boot loader operating”. На картинке ниже видим, что при переводе в машинный код этот текст хранится в позиции 0x7C10.

5. Мы будем использовать видеосервисы BIOS для отображения текста на экране, поэтому сейчас мы настраиваем отображение по своему желанию. Сервис перемещает байт 0x0E в регистр AH.

6. Ещё одна ссылка на метку, позволяющая управлять потоком выполнения. Позднее мы используем её для создания цикла.

7. Эта инструкция загружает байт из операнда-источника в регистр AL. Вспомните четвёртую строку, где регистру SI была задана позиция текстового адреса. Теперь эта инструкция получает символ, хранящийся в ячейке памяти 0x7C10. Важно заметить, что она ведёт себя как массив, и мы указываем на первую позицию, содержащую символ ‘H’, как видно на рисунке ниже. Этот текст будет представлен итеративно по вертикали, и каждый символ будет задаваться каждый раз. Кроме того, второй символ не был представлен снимком, извлечённым из программы IDA. 0x65 в ASCII отображает символ ‘e’:

8. Выполнение логической операции OR между (AL | AL) на первый взгляд кажется бессмысленным, однако это не так. Нам нужно проверить, равен ли результат этой операции нулю, основываясь на логическом булевом значении. После этой операции результат будет, например, [1 | 1 = 1] или [0 | 0 = 0].

9. Переход к метке остановки (строка 12), если результат последней операции OR равен нулю. В первый момент значение AL равно [0x48 = ‘H’] , основываясь на последней инструкции LODSB, помните строку 7? Значит, код не перейдёт к метке остановки в первый раз. Почему так? (0x48 OR 0x48) = 0x48, следовательно он переходит к следующей инструкции на следующей строке. Важно заметить, что инструкция JZ связана не только с инструкцией OR. Существует другой регистр, FLAGS, который наблюдается в процессе операций перехода, то есть результат операции OR хранится в этом регистре FLAG и наблюдается инструкцией JZ.

10. Вызывая прерывание BIOS, инструкция INT 0x10 отображает значение AL на экране. Вспомните строку 5, мы задали значение AH байтом 0x0E. Это комбинация для представления значения AL на экране.

11. Переход к метке loop, которая без всяких условий похожа на инструкцию GOTO в языках высокого уровня.

12. Мы снова на строке 7, LODSB перехватывает контроль. После того, как байт будет перемещён из адреса в памяти в регистр AL, регистр SI инкрементируется. Во второй раз он указывает на адрес 0x7C11 = [0x65 ‘e’], затем на экране отображается символ ‘e’. Этот цикл будет выполняться до тех пор, пока не достигнет адреса 0x7C3B = [0x00 0], и, когда JZ снова выполнится в строке 9, поток будет доведён до метки остановки.

13. Здесь мы заканчиваем наше путешествие. Выполнение останавливают инструкции CLI и HLT.

14. На строке 17 вы видите инструкцию, которая заполняет оставшиеся 510 байтов нулями после чего добавляет подпись загрузочной записи 0xAA55.

Компилируем и запускаем

Убедитесь, что компилятор NASM и эмулятор виртуальной машины QEMU установлены на ваш компьютер. Воспользуйтесь предпочтительным менеджер зависимостей или скачайте их из интернета.

Для Linux наберите в терминале:

sudo apt-get install nasm qemu

На Mac OS можно использовать homebrew:

brew install nasm qemu

После этого вам нужно создать файл с кодом сборки, представленным в коде загрузчика выше. Давайте назовём этот файл boot.asm и затем запустим команду NASM:

nasm -f bin boot.asm -o boot.bin

Будет создан двоичный файл, который нужно запустить на виртуальной машине. Давайте запустим на QEMU:

qemu-system-x86_64 -fda boot.bin

Вы увидите следующий экран:

Запуск из Virtual box

Сначала вам нужно создать виртуальный пустой флоппи диск:

dd if=/dev/zero bs=1024 count=0 > floppy.img

Затем добавить внутрь него двоичное содержимое:

cat boot.bin >> floppy.img

Теперь вы можете создать машину Virtual Box и запустить её, используя файл загрузки:

Многие вещи я не стал здесь рассматривать, чтобы не быть слишком многословным. Если вы новичок в этой непростой теме, у вас наверняка возникло множество вопросов, и это прекрасная отправная точка для исследований. Для лучшего понимания многих принципов вычислительных и операционных систем я рекомендую книгу Эндрю С. Таненбаума “Операционные системы. Разработка и реализация”.

Создание загрузочного сектора

21.08.2011

При загрузке компьютера BIOS считывает первый сектор дискового накопителя (жесткий/гибкий диск/DVD/CDROM)
(MBR) в оперативную память по адресу 0000:7С00h и передает туда управление. Затем уже загрузчик передает управление операционной системе.
Чтобы BIOS мог идентифицировать программу начальной загрузки, она в конце должна содержать ключ 55h 0aah.

Начальный загрузчик может выглядеть примерно так (для создания исполняемого файла воспользуемся MASMом и скомпилируем com-файл)

;===================== Загрузочный сектор. Евгений Попов, 2011===================== 
;==================================================================================

.model tiny ;для того чтобы masm скомпилировал односегментную программу не более 512 байт
CSEG segment
assume CS:CSEG

org 7c00h 	;BIOS производит чтение 512 байт первого сектора MBR в ОЗУ по адресу 0x00007C00 
			;(0x07C0:0x0000 в формате реального режима), затем прочитанному коду передаётся управление
start:
		cli ;запрещаем прерывания
        xor ax,ax	;обнуляем регистр ах
        mov ds,ax	;настраиваем сегмент данных на нулевой адрес
        mov es,ax	;настраиваем сегмент es на нулевой адрес
        mov ss,ax	;настраиваем сегмент стека на нулевой адрес
        mov sp,07C00h	;сегмент sp указывает на текущую вершину стека
        sti	;разрешаем прерывания
        
        ;очищаем экран
        mov al, 02h
  		mov ah, 00h
  		int 10h
        
        call GetCursorPos	;получаем позицию курсора
                                
        mov bp, offset msg             ; Загрузка
        mov cx, 15
        call print					;Вывод на экран строки msg
        
        add dh,1	;переходим на одну строку ниже
        call SetCursorPos
        mov bp, offset Con             ; Загрузка
        mov cx, 23
        call print
        
        mov dx,1701h
        call SetCursorPos
        mov bp,offset Off
        mov cx,30
        call print
        
        mov bp, offset Copyright
        mov cx,30
        add dh,01h
        call SetCursorPos
        call print
                
        call Char_in 
                
        cmp al,'o'
        jz Turn_Off
        cmp al,'r'
        jz Restart
        ;cmp al, 0Dh ;Если нажимаем на Enter, то переходим к загрузке ядра
        ;jz Kernel   ;поскольку ядра нет, код оставлен на будущее
                
        jmp $
;===================== Подпрограммы ===================================
  print:                             ;в регистре  bp - строка, в регистре cx - длина этой строки
        mov bl,04h					;в регистре  bl- атрибут
        mov ax,1301h
        int 10h
        ret
        ;----------------------------------
  GetCursorPos:	;получаем текущее значение курсора функиция 3h прерывания 10h
        				; в bh страница
        mov ah,3h
        xor bh,bh
        int 10h
        ret
        ;----------------------------------
  SetCursorPos:        ;установка курсора : функция 02h прерывания 10h
        mov ah,2h
        xor bh,bh
        int 10h 
        ret
      ;----------------------------------
  Char_in:              ;ожидание нажатой клавиши : функция 10h прерывания 16h
         mov ah,10h
         int 16h
         ret
        ;----------------------------------
  Turn_Off:				;выключение компа
        mov ax,5301h 
        sub bx,bx 
        int 15h 
        jb stop 
        mov ax,530eh 
        sub bx,bx 
        int 15h 
        jb stop 
        mov ax,5307h 
        mov bx,0001h 
        mov cx,0003h 
        int 15h
   stop:
        ret
  Restart:
        jmp dword ptr reboot
            
        ;===================== выводимые сообщения===================== 
      	msg db Hello Eugene...',0     
        Off db   'r --restart       o --turn off',0
        Copyright db 'Copyright ',1,' Eugene Popov, 2011',0
        Con db 'Press Enter to Continue',0
        
        reboot dd 0ffff0000h ;переход по этому адресу будет вызывать перезагрузку
         
	;----------------------------------
codeend:
db 510-(codeend-start) dup (0)	;заполняем оставшуюся часть нулями
db 055h,0AAh ;сигнатура, символизирующая о завершении загрузочного сектора
CSEG ends
end start

Теперь выведем результат программы. Для этого воспользуемся эмулятором Bochs.
Сначала нам надо создать конфигурационный файл для программы — в моем случае он выглядит так

# configuration file generated by Bochs
plugin_ctrl: unmapped=1, biosdev=1, speaker=1, extfpuirq=1, gameport=1, pci_ide=1, acpi=1, ioapic=1
config_interface: win32config
display_library: win32
memory: host=32, guest=10
romimage: file="C:Program FilesBochs-2.4.6/BIOS-bochs-latest"
vgaromimage: file="C:Program FilesBochs-2.4.6/VGABIOS-lgpl-latest"
boot: disk
floppy_bootsig_check: disabled=0
# no floppya
# no floppyb
ata0: enabled=1, ioaddr1=0x1f0, ioaddr2=0x3f0, irq=14
ata0-master: type=disk, mode=flat, translation=auto, path="C:UsersEugeneNBOOT1.COM", cylinders=1, heads=1, spt=1, biosdetect=auto, model="Generic 1234"
ata0-slave: type=disk, mode=flat, translation=auto, path="C:UsersEugeneASMBOOT12.BIN", cylinders=20, heads=16, spt=63, biosdetect=auto, model="Generic 1234"
ata1: enabled=1, ioaddr1=0x170, ioaddr2=0x370, irq=15
ata2: enabled=0
ata3: enabled=0
parport1: enabled=1, file=""
parport2: enabled=0
com1: enabled=1, mode=null, dev=""
com2: enabled=0
com3: enabled=0
com4: enabled=0
usb_uhci: enabled=0
usb_ohci: enabled=0
i440fxsupport: enabled=1
vga_update_interval: 50000
vga: extension=vbe
cpu: count=1, ips=4000000, reset_on_triple_fault=1, ignore_bad_msrs=1
cpuid: cpuid_limit_winnt=0, mmx=1, sse=sse2, xapic=1, sep=1, aes=0, xsave=0, movbe=0, 1g_pages=0, pcid=0 fsgsbase=0
cpuid: stepping=3, vendor_string="GenuineIntel", brand_string="              Intel(R) Pentium(R) 4 CPU        "
print_timestamps: enabled=0
port_e9_hack: enabled=0
text_snapshot_check: enabled=0
private_colormap: enabled=0
clock: sync=none, time0=local
# no cmosimage
ne2k: enabled=0
pnic: enabled=0
sb16: enabled=0
# no loader
log: -
logprefix: %t%e%d
panic: action=ask
error: action=report
info: action=report
debug: action=ignore
pass: action=fatal
keyboard_type: mf
keyboard_serial_delay: 250
keyboard_paste_delay: 100000
keyboard_mapping: enabled=0, map=
user_shortcut: keys=none
mouse: enabled=0, type=ps2, toggle=ctrl+mbutton

В данном случае у меня файл программы загрузки — C:UsersEugeneNBOOT1.COM

В итоге получим следующую картинку

Наш загрузочный сектор будет искать в корневом каталоге некоторый файл — загрузчик, загрузит его в память и передаст ему управление на его начало. А загрузчик уже сам разберется, что ему делать дальше. Я использую NASM, т.к. считаю, что он больше подходит для наших целей.

И так, приступим. Как я уже говорил, в начале нашего загрузочного сектора располагается заголовок FAT, опишем его:

; Общая часть для всех типов FAT
 BS_jmpBoot:
 jmp	short BootStart	; Переходим на код загрузчика
 nop
 BS_OEMName	db '*-v4VIHC'	; 8 байт, что было на моей дискете, то и написал
 BPB_BytsPerSec	dw 0x200	; Байт на сектор
 BPB_SecPerClus	db 1	; Секторов на кластер
 BPB_RsvdSecCnt	dw 1	; Число резервных секторов
 BPB_NumFATs	db 2	; Количектво копий FAT
 BPB_RootEntCnt	dw 224	; Элементов в корневом катологе (max)
 BPB_TotSec16	dw 2880	; Всего секторов или 0
 BPB_Media	db 0xF0	; код типа устройства
 BPB_FATsz16	dw 9	; Секторов на элемент таблицы FAT
 BPB_SecPerTrk	dw 18	; Секторов на дорожку
 BPB_NumHeads	dw 2	; Число головок
 BPB_HiddSec	dd 0	; Скрытых секторов
 BPB_TotSec32	dd 0	; Всего секторов или 0
 ; Заголовок для FAT12 и FAT16
 BS_DrvNum	db 0	; Номер дика для прерывания int 0x13
 BS_ResNT	db 0	; Зарезервировано для Windows NT
 BS_BootSig	db 29h	; Сигнатура расширения
 BS_VolID	dd 2a876CE1h	; Серийный номер тома
 BS_VolLab	db 'X boot disk'	; 11 байт, метка тома
 BS_FilSysType	db 'FAT12   '	; 8 байт, тип ФС
 ; Структура элемента каталога
 struc	DirItem
 	DIR_Name:	resb 11
 	DIR_Attr:	resb 1
 	DIR_ResNT:	resb 1
 	DIR_CrtTimeTenth	resb 1
 	DIR_CrtTime:	resw 1
 	DIR_CrtDate:	resw 1
 	DIR_LstAccDate:	resw 1
 	DIR_FstClusHi:	resw 1
 	DIR_WrtTime:	resw 1
 	DIR_WrtDate:	resw 1
 	DIR_FstClusLow:	resw 1
 	DIR_FileSize:	resd 1
 endstruc ;DirItem
 

Большинство полей мы использовать не будем, и так мало места для полета. Загрузчик BIOS передает нам управление на начало загрузочного сектора, т.е. на BS_jmpBoot, поэтому в начале заголовка FAT на отводится 3 байта для короткой или длинной инструкции jmp. Мы в данном случае использовали короткую, указав модификатор short, и в третьем байте просто разместили однобайтовую инструкцию nop.

По инструкции jmp short BootStart мы переходим на наш код. Проведем небольшую инициализацию:

; Наши не инициализированные переменные
 ; При инициализации они затрут не нужные нам
 ; поля заголовка FAT: BS_jmpBoot и BS_OEMName
 struc	NotInitData
 	SysSize:	resd 1	; Размер системной области FAT
 	fails:	resd 1	; Число неудачных попыток при чтении
 	fat:	resd 1	; Номер загруженного сектора с элементами FAT
 endstruc ;NotInitData
 ; По этому адресу мы будем загружать загрузчик
 %define SETUP_ADDR	0x1000
 ; А по этому адресу нас должны были загрузить
 %define BOOT_ADDR	0x7C00
 %define BUF	0x500
 BootStart:
 	cld
 	xor	cx, cx
 	mov	ss, cx
 	mov	es, cx
 	mov	ds, cx
 	mov	sp, BOOT_ADDR
 	mov	bp, sp
 	; Сообщим о том что мы загружаемся
 	mov	si, BOOT_ADDR + mLoading
 	call	print
 

Все сегментные регистры настраиваем на начало физической памяти. Вершину стека настраиваем на начало нашего сектора, стек растет вниз (т.е. в сторону младших адресов), так что проблем быть не должно. Туда же указывает регистр bp — нам нужно обращаться к полям заголовка FAT и паре наших переменных. Мы используем базовую адресацию со смещением, для чего используем регистр bp т.к. в этом случае можно использовать однобайтовые смещения, вместо двухбайтовых адресов, что позволяет сократить код. Процедуру print, выводящую сообщение на экран, рассмотрим позже.

Теперь нам нужно вычислить номера первых секторов корневого каталога и данных файлов.

	mov	al, [byte bp+BPB_NumFATs]
 	cbw
 	mul	word [byte bp+BPB_FATsz16]
 	add	ax, [byte bp+BPB_HiddSec]
 	adc	dx, [byte bp+BPB_HiddSec+2]
 	add	ax, [byte bp+BPB_RsvdSecCnt]
 	adc	dx, cx
 	mov	si, [byte bp+BPB_RootEntCnt]
 	; dx:ax - Номер первого сектора корневого каталога
 	; si - Количество элементов в корневом каталоге
 	pusha
 	; Вычислим размер системной области FAT = резервные сектора +
 	; все копии FAT + корневой каталог
 	mov	[bp+SysSize], ax	; осталось добавить размер каталога
 	mov	[bp+SysSize+2], dx
 	; Вычислим размер корневого каталога
 	mov	ax, 32
 	mul	si
 	; dx:ax - размер корневого каталога в байтах, а надо в секторах
 	mov	bx, [byte bp+BPB_BytsPerSec]
 	add	ax, bx
 	dec	ax
 	div	bx
 	; ax - размер корневого каталога в секторах
 	add	[bp+SysSize], ax	; Теперь мы знаем размер системной
 	adc	[bp+SysSize+2], cx	; области FAT, и начало области данных
 	popa
 	; В dx:ax - снова номер первого сектора корневого каталога
 	; si - количество элементов в корневом каталоге

Теперь мы будем просматривать корневой каталог в поисках нужного нам файла

NextDirSector:
 	; Загрузим очередной сектор каталога во временный буфер
 	mov	bx, 700h	; es:bx - буфер для считываемого сектора
 	mov	di, bx	; указатель текущего элемента каталога
 	mov	cx, 1	; количество секторов для чтения
 	call	ReadSectors
 	jc	near DiskError	; ошибка при чтении
 RootDirLoop:
 	; Ищем наш файл
 	; cx = 0 после функции ReadSectors
 	cmp	[di], ch	; byte ptr [di] = 0?
 	jz	near NotFound	; Да, это последний элемент в каталоге
 	; Нет, не последний, сравним имя файла
 	pusha
 	mov	cl, 11	; длина имени файла с расширением
 	mov	si, BOOT_ADDR + LoaderName	; указатель на имя искомого файла
 	rep	cmpsb	; сравниваем
 	popa
 	jz	short Found	; Нашли, выходим из цикла
 	; Нет, ищем дальше
 	dec	si	; RootEntCnt
 	jz	near NotFound	; Это был последний элемент каталога
 	add	di, 32	; Переходим к следующему элементу каталога
 	; bx указывает на конец прочтенного сектора после call ReadSectors
 	cmp	di, bx	; Последний элемент в буфере?
 	jb	short RootDirLoop	; Нет, проверим следующий элемент
 	jmp	short NextDirSector	; Да последний, загрузим следующий сектор

Из этого кода мы можем выйти одну из трех точек: ошибка при чтении DiskError, файл наден Found или файл не найден NotFound.

Загрузка файла в память 

Если файл найден, то загрузим его в память и передадим управление на его начало.

Found:
 	; Загрузка загрузчика (извените, калабур)
 	mov	bx, SETUP_ADDR
 	mov	ax, [byte di+DIR_FstClusLow]	; Номер первого кластера файла
 	; Загружаем сектор с элемнтами FAT, среди которых есть FAT[ax]
 	; LoadFAT сохраняет значения всех регистров
 	call	LoadFAT
 ReadCluster:
 	; ax - Номер очередного кластера
 	; Загрузим его в память
 	push	ax
 	; Первые два элемента FAT служебные
 	dec	ax
 	dec	ax
 	; Число секторов для чтения
 	; cx = 0 после ReadSectors
 	mov	cl, [byte bp+BPB_SecPerClus]	; Секторов на кластер
 	mul	cx
 	; dx:ax - Смещение кластера относительно области данных
 	add	ax, [byte bp+SysSize]
 	adc	dx, [byte bp+SysSize+2]
 	; dx:ax - Номер первого сектора требуемого кластера
 	; cx еще хранит количество секторов на кластер
 	; es:bx - конец прошлого кластера и начало нового
 	call	ReadSectors	; читаем кластер
 	jc	near DiskError	; Увы, ошибка чтения
 	pop	ax	; Номер кластера
 	; Это конец файла?
 	; Получим значение следующего элемента FAT
 	pusha
 	; Вычислим адрес элемента FAT
 	mov	bx, ax
 	shl	ax, 1
 	add	ax, bx
 	shr	ax, 1
 	; Получим номер сектора, в котором находится текущий элемент FAT
 	cwd
 	div	word [byte bp+BPB_BytsPerSec]
 	cmp	ax, [bp+fat]	; Мы уже читали этот сектор?
 	popa
 	je	Checked	; Да, читали
 	; Нет, надо загрузить этот сектор
 	call	LoadFAT
 Checked:
 	; Вычислим адрес элемента FAT в буфере
 	push	bx
 	mov	bx, ax
 	shl	bx, 1
 	add	bx, ax
 	shr	bx, 1
 	and	bx, 511	; остаток от деления на 512
 	mov	bx, [bx+0x700]	; а вот и адрес
 	; Извлечем следующий элемент FAT
 	; В FAT16 и FAT32 все немного проще :(
 	test	al, 1
 	jnz	odd
 	and	bx, 0xFFF
 	jmp	short done
 odd:
 	shr	bx, 4
 done:
 	mov	ax, bx
 	pop	bx
 	; bx - новый элемент FAT
 	cmp	ax, 0xFF8	; EOF - конец файла?
 	jb	ReadCluster	; Нет, читаем следующий кластер
 	; Наконец-то загрузили
 	mov	ax, SETUP_ADDR>>4	; SETUP_SEG
 	mov	es, ax
 	mov	ds, ax
 	; Передаем управление, наше дело сделано :)
 	jmp	SETUP_ADDR>>4:0
 	 LoadFAT	;proc
 ; Процедура для загрузки сектора с элементами FAT
 ; Элемент ax должен находится в этом секторе
 ; Процедура не должна менять никаких регистров
 	pusha
 	; Вычисляем адрес слова содержащего нужный элемент
 	mov	bx, ax
 	shl	ax, 1
 	add	ax, bx
 	shr	ax, 1
 	cwd
 	div	word [byte bp+BPB_BytsPerSec]
 	; ax - смещение сектора относительно начала таблицы FAT
 	mov	[bp+fat], ax	; Запомним это смещение, dx = 0
 	cwd			; dx:ax - номер сектора, содержащего FAT[?]
 	; Добавим смещение к первой копии таблицы FAT
 	add	ax, [byte bp+BPB_RsvdSecCnt]
 	adc	dx, 0
 	add	ax, [byte bp+BPB_HiddSec]
 	adc	dx, [byte bp+BPB_HiddSec+2]
 	mov	cx, 1	; Читаем один сектор. Можно было бы и больше, но не быстрее
 	mov	bx, 700h	; Адрес буфера
 	call	ReadSectors
 	jc	DiskError	; Ошибочка вышла
 	popa
 	ret
 ;LoadFAT	endp

В FAT12 на каждый элемент FAT отводится по 12 бит, что несколько усложняет нашу работу, в FAT16 и FAT32 на каждый элемент отводится по 16 и 32 бита соответственно и можно просто прочесть слово или двойное слово, а в FAT12 необходимо прочесть слово содержащее элемент FAT и правильно извлечь из него 12 бит.

Процедура загрузки секторов

Теперь разберем процедуру загрузки секторов. Процедура получает номер сектора в dx:ax (нумерация с нуля) и преобразует его к формату CSH (цилиндр, сектор, сторона), используемому прерыванием BIOS int 0x13.

<>; *************************************************

 ; *          Чтение секторов с диска              *

 ; *************************************************

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

 ; * dx:ax       - (LBA) номер сектора             *

 ; * cx          - количество секторов для чтения  *

 ; * es:bx       - адрес буфера                    *

 ; *************************************************

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

 ; * cx       - Количество не прочтенных секторов  *

 ; * es:bx    - Указывает на конец буфера          *

 ; * cf = 1   - Произошла ошибка при чтении        *

 ; *************************************************

 ReadSectors	;proc

 next_sector:

 	; Читаем очередной сектор

 	mov	byte [bp+fails], 3	; Количество попыток прочесть сектор

 try:

 	; Очередная попытка

 	pusha

 	; Преобразуем линейный адрес в CSH

 	; dx:ax = a1:a0

 	xchg	ax, cx		; cx = a0

 	mov	ax, [byte bp+BPB_SecPerTrk]

 	xchg	ax, si		; si = Scnt

 	xchg	ax, dx		; ax = a1

 	xor	dx, dx

 	; dx:ax = 0:a1

 	div	si		; ax = q1, dx = c1

 	xchg	ax, cx		; cx = q1, ax = a0

 	; dx:ax = c1:a0

 	div	si		; ax = q2, dx = c2 = c

 	inc	dx		; dx = Sector?

 	xchg	cx, dx		; cx = c, dx = q1

 	; dx:ax = q1:q2

 	div	word [byte bp+BPB_NumHeads]	; ax = C (track), dx = H

 	mov	dh, dl		; dh = H

 	mov	ch, al

 	ror	ah, 2

 	or	cl, ah

 	mov	ax, 0201h		; ah=2 - номер функции, al = 1 сектор

 	mov	dl, [byte bp+BS_DrvNum]

 	int	13h

 	popa

 	jc	Failure	; Ошибка при чтении

 	; Номер следующего сектора

 	inc	ax

 	jnz	next

 	inc	dx

 next:

 	add	bx, [byte bp+BPB_BytsPerSec]

 	dec	cx	; Все сектора прочтены?

 	jnz	next_sector	; Нет, читаем дальше

 return:

 	ret

 Failure:

 	dec	byte [bp+fails]	; Последняя попытка?

 	jnz	try	; Нет, еще раз

 	; Последняя, выходим с ошибкой

 	stc

 	ret

 ;ReadSectors	endp

; Сообщения об ошибках
 NotFound:	; Файл не найден
 	mov	si, BOOT_ADDR + mLoaderNotFound
 	call	print
 	jmp	short die
 DiskError:	; Ошибка чтения
 	mov	si, BOOT_ADDR + mDiskError
 	call	print
 	;jmp	short die	
 die:	; Просто ошибка
 	mov	si, BOOT_ADDR + mReboot
 	call	print
 _die:	; Бесконечный цикл, пользователь сам нажмет Reset
 	jmp	short _die
 ; Процедура вывода ASCIIZ строки на экран
 ; ds:si - адрес строки
 print:	; proc
 	pusha
 print_char:
 	lodsb	; Читаем очередной символ
 	test	al, al	; 0 - конец?
 	jz	short pr_exit	; Да конец
 	; Нет, выводим этот символ
 	mov	ah, 0eh
 	mov	bl, 7
 	int	10h
 	jmp	short print_char	; Следующий
 pr_exit:
 	popa
 	ret
 ;print	endp
 ; Перевод строки
 %define	endl 10,13,0
 ; Строковые сообщения
 mLoading	db 'Loading...',endl
 mDiskError	db 'Disk I/O error',endl
 mLoaderNotFound	db 'Loader not found',endl
 mReboot		db 'Reboot system',endl
 ; Выравнивание размера образа на 512 байт
 times 499-($-$$) db 0
 LoaderName	db 'BOOTOR     '	; Имя файла загрузчика
 BootMagic	dw 0xAA55	; Сигнатура загрузочного сектора

> nasm -f bin boot.asm -lboot.lst -oboot.bin

Introduction

In the previous article, I tried to brief about booting, how to write a bootable code in C and assembly, and how to embed assembly statements inside a
C program as well.
We also tried to write a few programs to examine if our code injected into the boot sector of a device works or not. In this article, I will try to explain about segmentation
and reading data from a floppy disk during booting and displaying it onto the screen. We will try writing
a few programs
and examine if we can read the data and try displaying it onto the screen.

What is the scope of the article?

I will limit the scope of the article onto how to write a program code in assembly, and how to copy it to the boot sector of a 3.5 inches floppy disk image,
and then how to test the floppy disk to boot it with the code we have written using an x86 emulator like bochs. I will take the help of BIOS services to achieve the task
of reading data from a floppy disk. By doing so we can explore more about BIOS routines and feel comfortable playing around in Real Mode.

Breakdown of topics

• Introduction to segmentation
• Programming environment
• Reading data from RAM-Memory
• Introduction to storage devices
• Architecture of a floppy disk
• Interaction with a floppy disk

Introduction to Segmentation

Before I proceed writing some examples on how to read a floppy disk, I wanted to refresh the topic of segmentation and its need as below.

What is
Segmentation?

The main memory is divided into segments that are indexed by few special registers called as segment registers (CS, DS, SS and ES).

What is the use of
Segmentation?

When we specify a 16-bit address, the CPU automatically calculates the start address of the respective segment. However, it is the duty of the programmer
to specify the start address of each segment especially when writing a program like boot loader.

What are the different types of segments?

I will mention only four types for now, as they are important for us to understand.

• Code Segment
• Data Segment
• Stack Segment
• Extended Segment

Code Segment

It is one of the sections of a program in memory that contains the executable instructions.
If you refer to my previous article, you will see the label .text where under which we intend to place the instructions to execute. When the program is loaded into memory,
the instructions under section .text are placed into code segment.
In CPU, we use CS register to refer to the code segment in memory.

Data Segment

It is one of the sections of a program in memory that contains variables both static and global by the programmer. We use DS register to refer to the data segment in memory.

Stack Segment

A programmer can use registers to store, modify and retrieve data during the scope of the program
that he has written. As there are only a few registers available for a programmer to use during the run time of the program, there is always a chance that the program logic
might get complicated, as there are only a few registers available for temporary use. Due to this, the programmer might always feel the need for a bigger place, which is more flexible
in terms of storing, processing and retrieving data. The CPU designers have come up with a special segment called the stack segment.
In order to store and retrieve data on stack segment, the programmer uses push and pop instructions. We use push instructions to pass arguments to functions as well.
We use SS register to refer to the stack segment in memory. Also remember that stack grows downwards.

Extended Segment:

The extended segment is normally used to load data that is much bigger than the size of the data that is stored in data segment. You will further see that I will try to load the data
from the floppy on Extended segment. We use ES register to refer to the Extended Segment in memory.

How to set Segment registers?

The programmer does not have the freedom to directly set any of the segment registers but instead we follow this way.

movw $0x07c0, %ax
movw %ax, %ds 

What does the above step means?

• Copy the data to a general purpose register.
• Then assign it to the segment register.

We are setting AX register to 0x07c0

And when we are copying the contents of AX to DS. The absolute address is calculated as below.

DS = 16 * AX
So DS = 0x7c00

We further use offset to traverse from here on. To reach to a location in Data segment, we use offsets.

Programming environment

• Operating system (GNU Linux)
• Assembler (GNU Assembler)
• Compiler (GNU GCC)
• Linker (GNU linker ld)
• An x86 emulator used for our testing purposes(bochs).

Reading data from RAM

Note

Now, if you observe BIOS loads our program at 0x7c00 and starts executing it and then our program starts printing values one by one. We access the data on RAM by directly specifying
the offset and setting the data segment to 0x7c00.

Example1

Once our program is loaded by BIOS at 0x7c00, let us try to read data from offset 3 and 4 and then print them onto the screen.

Program: test.S

.code16                   #generate 16-bit code
.text                     #executable code location
     .globl _start
_start:                   #code entry point
     jmp  _boot           #jump to boot code
     data : .byte 'X'     #variable
     data1: .byte 'Z'     #variable
_boot:
     movw $0x07c0, %ax    #set ax = 0x07c0
     movw %ax    , %ds    #set ds = 16 * 0x07c0 = 0x7c00
     #Now we will copy the data at position 3 from 0x7c00:0x0000
     # and then print it onto the screen
     movb 0x02   , %al    #copy the data at 2nd position to %al
     movb $0x0e  , %ah
     int  $0x10
    #Now we will copy the data at position 4 from 0x7c00:0x0000
    # and then print it onto the screen
     movb 0x03   , %al    #copy the data at 3rd position to %al
     movb $0x0e  , %ah
     int  $0x10
#infinite loop
_freeze:
     jmp _freeze
     . = _start + 510     #mov to 510th byte from 0 pos
     .byte 0x55           #append boot signature
     .byte 0xaa           #append boot signature 

Now on the command line, to generate binary and to copy the code to boot sector of a floppy disk, type as below and then hit return.

• as test.S –o test.o
• ld –Ttext=0x7c00 –oformat=binary boot.o –o boot.bin
• dd if=/dev/zero of=floppy.img bs=512 count=2880
• dd if=boot.bin of=floppy.img

Note

If you open the boot.bin file in hexadecimal editor, you will see something similar as below.

You will see that X and Y are in the third and fourth position from 0th offset of 0x7c00.

To test the code, type the following commands as below.

• bochs

Example:

Once our program is loaded by BIOS at 0x7c00, let us read a null terminated string from offset 2 and then print it.

Program: test2.S

.code16                                     #generate 16-bit code
.text                                       #executable code location
     .globl _start
_start:                                     #code entry point
     jmp  _boot                             #jump to boot code
     data : .asciz "This is boot loader"    #variable
     #calls the printString function which
     #starts printing string from the position
     .macro mprintString start_pos          #macro to print string
          pushw %si
          movw  start_pos, %si
          call  printString
          popw  %si
     .endm 
     printString:                           #function to print string
     printStringIn:
          lodsb
          orb %al   , %al
          jz  printStringOut
          movb $0x0e, %ah
          int  $0x10
          jmp  printStringIn
     printStringOut:
     ret
_boot:
     movw $0x07c0, %ax                      #set ax = 0x07c0
     movw %ax    , %ds                      #set ds = 16 * 0x07c0 = 0x7c00
     mprintString $0x02
_freeze:
     jmp _freeze
     . = _start + 510                       #mov to 510th byte from 0 pos
     .byte 0x55                             #append boot signature
     .byte 0xaa                             #append boot signature  

If you compile the program and open the binary in hexadecimal editor, you may see the string as “This is boot loader” onto output.

Introduction to storage devices

What is a storage device?

It is a device used for information storage, retrieval. It can also be used as a bootable media.

Why does a computer require storage devices?

We use computers mainly to store information, retrieve the information and process it so as part of storing and retrieval
of information, the manufactures came up with a new device called a storage device with various types.

What are the various types of storage devices available?

Depending on the size of the data, I will try to list them as below.

• Floppy disk
• Hard disk
• USB Disk

And more…

What is a floppy disk?

It is a device used for information storage, retrieval. It is also used as a bootable media.

A floppy disk is designed to store small amounts of data whose maximum size
could be limited to few Mega Bytes.

What is a Mega Byte?

In computing, the size of the data is measured in one of the following ways:

• Bit: It can store
  a value of either a 1 or 0
• Nibble: 4 bits
• Byte(B): 8 bits
• Kilo Byte(KB): 1024 bytes
• Mega Byte(MB): 1 Kilo Byte * 1 Kilo Byte = 1,048,576 Bytes = 1024 Kilo Bytes = 1024 * 1024 Bytes
• Giga Byte(GB): 1,073,741,824 Bytes= 2^30 Bytes = 1024 Mega Bytes = 1,048,576 Kilo Bytes = 1024 * 1024 * 1024 Bytes
• Tera Byte(TB): 1,099,511,627,776 Bytes= 2^40 Bytes = 1024 Giga Bytes = 1,048,576 Megabytes = 1024 * 1024 * 1024 * 1024 Bytes

And more…but we will limit our selves to the above.

How does a floppy disk look like?

How much data can I store on a floppy disk?

It all depends upon various types of floppy disks available from manufactures and their respective sizes.

I will simply try to list the details of 3.5 inches floppy disk which I have used earlier in my life.

Name            Description              Size(mm)            Volume(mm2)     Capicity(MB)
3.5 inches   3.5 inch Floppy Disk 	93.7 x 90.0 x 3.3     27,828.9 	       1.44 MB

Architecture of a typical floppy disk

The above diagram shows you the architecture of a typical floppy disk and let us be concerned about
3.5 inches floppy disk and I will explain more about it as below.

How to describe a 3.5 inches floppy disk?

• It has 2 sides
• It side is called as a head.
• Each Side contains 80 tracks on it.
• Each track contains 18 sectors in it.
• Each sector contains 512 bytes in it.

How to calculate the size of a floppy disk?

• Total Size in Bytes: Total sides * Total tracks * Total Sectors Per Track * Total Bytes Per Sector.

Total Size(Bytes) = 2 * 80 * 18 * 512 = 1474560 Bytes.

• Total Size in Kilo Bytes: (Total sides * Total tracks * Total Sectors Per Track * Total Bytes)/1024.

Total Size(KB) = (2 * 80 * 18 * 512)/1024 = 1474560/1024 = 1440 KB.

• Total Size in Mega Bytes: ((Total sides * Total tracks * Total Sectors Per Track * Total Bytes)/1024)/1024

Total Size(MB) = ((2 * 80 * 18 * 512)/1024)/1024 = (1474560/1024)/1024 = 1440/1024 = 1.4 MB

Where is boot sector located on a floppy disk?

It is located on the first sector of the disk.

Interaction with a floppy disk

How to read data from a floppy disk?

As our mission in this article is to read data from a floppy disk, the only choice left to us as of now is to use BIOS Services in our program as during the boot time we are in Real Mode to interact with the floppy disk. We need to use BIOS Interrupts to achieve our task.

Which interrupts are we going to use?

Interrupt 0x13
Service code 0x02

How to access a floppy disk using the interrupt 0x13?

• To request BIOS to read a sector on a floppy we use below.

AH = 0x02

• To request BIOS to read from the ‘N’th cylinder we use below.

CH = ‘N’

• To request BIOS to read from the ‘N’th head we use below.

DH = ‘N’

• To request BIOS to read ‘N’th sector we use below.

CL = ‘N’

• To request BIOS to read ‘N’ number of sectors we use below.

AL = N

• To interrupt the CPU to perform this activity we use below.

Int 0x13

Reading data from Floppy Disk

Let us write a program to display the labels of few sectors.

Program: test.S

.code16                       #generate 16-bit code
.text                         #executable code location
.globl _start
_start:
     jmp _boot                #jump to the boot code to start execution
     msgFail: .asciz "something has gone wrong..." #message about erroneous operation
      #macro to print null terminated string
      #this macro calls function PrintString
     .macro mPrintString str
          leaw str, %si
          call PrintString
     .endm
     #function to print null terminated string
     PrintString:
          lodsb
          orb  %al  , %al
          jz   PrintStringOut
          movb $0x0e, %ah
          int  $0x10
          jmp  PrintString
     PrintStringOut:
     ret
     #macro to read a sector from a floppy disk
     #and load it at extended segment
     .macro mReadSectorFromFloppy num
          movb $0x02, %ah     #read disk function
          movb $0x01, %al     #total sectors to read
          movb $0x00, %ch     #select cylinder zero
          movb $0x00, %dh     #select head zero
          movb num, %cl      #start reading from this sector
          movb $0x00, %dl     #drive number
          int  $0x13          #interrupt cpu to get this job done now
          jc   _failure       #if fails then throw error
          cmpb $0x01, %al     #if total sectors read != 1
          jne  _failure       #then throw error
     .endm
     #display the string that we have inserted as the
     #identifier of the sector
     DisplayData:
     DisplayDataIn:
          movb %es:(%bx), %al
          orb  %al      , %al
          jz   DisplayDataOut
          movb $0x0e    , %ah
          int  $0x10
          incw %bx
          jmp  DisplayDataIn
     DisplayDataOut:
     ret
_boot:
     movw  $0x07c0, %ax       #initialize the data segment
     movw  %ax    , %ds       #to 0x7c00 location
     movw  $0x9000, %ax       #set ax = 0x9000
     movw  %ax    , %es       #set es = 0x9000 = ax
     xorw  %bx    , %bx       #set bx = 0
     mReadSectorFromFloppy $2 #read a sector from floppy disk
     call DisplayData         #display the label of the sector
     mReadSectorFromFloppy $3 #read 3rd sector from floppy disk
     call DisplayData         #display the label of the sector
_freeze:                      #infinite loop
     jmp _freeze              #
_failure:                     #
     mPrintString msgFail     #write error message and then
     jmp _freeze              #jump to the freezing point
     . = _start + 510         #mov to 510th byte from 0 pos
     .byte 0x55               #append first part of the boot signature
     .byte 0xAA               #append last part of the boot signature
_sector2:                     #second sector of the floppy disk
     .asciz "Sector: 2nr"   #write data to the begining of the sector
     . = _sector2 + 512       #move to the end of the second sector
_sector3:                     #third sector of the floppy disk
     .asciz "Sector: 3nr"   #write data to the begining of the sector
     . = _sector3 + 512       #move to the end of the third sector

Now compile the code as below

• as test.S -o test.o
• ld -Ttext=0x0000 —oformat=binary test.o -o test.bin
• dd if=test.bin of=floppy.img

If you open the test.bin in an hexadecimal editor you will find that I have embedded a label to sector 2 and 3. I have highlighted them in the below snapshot.

If you run the program by typing bochs on command prompt you will see as below.

What is the functionality of the above program?

In the above program we define macros and functions to read and display the contents of the strings that are embedded in each sector.

Let me brief you about each macro and function.

#macro to print null terminated string
#this macro calls function PrintString
.macro mPrintString str
  leaw str, %si
  call PrintString
.endm

This macro is defined to take a string as an argument and internally it calls another function called
PrintString which does the job of displaying character by character onto the screen.

#function to print null terminated string
PrintString:
  lodsb
  orb  %al  , %al
  jz   PrintStringOut
  movb $0x0e, %ah
  int  $0x10
  jmp  PrintString
PrintStringOut:
Ret

This is the function called by the macro mPrintString to display each byte of the null terminated string onto the screen.

#macro to read a sector from a floppy disk
 #and load it at extended segment
 .macro mReadSectorFromFloppy num
      movb $0x02, %ah     #read disk function
      movb $0x01, %al     #total sectors to read
      movb $0x00, %ch     #select cylinder zero
      movb $0x00, %dh     #select head zero
      movb num, %cl      #start reading from this sector
      movb $0x00, %dl     #drive number
      int  $0x13          #interrupt cpu to get this job done now
      jc   _failure       #if fails then throw error
      cmpb $0x01, %al     #if total sectors read != 1
      jne  _failure       #then throw error
 .endm

This macro mReadSectorFromFloppy reads a sector into the extended segment and places there for further processing. This macro takes a sector number to read as an argument.

#display the string that we have inserted as the
#identifier of the sector
DisplayData:
DisplayDataIn:
  movb %es:(%bx), %al
  orb  %al      , %al
  jz   DisplayDataOut
  movb $0x0e    , %ah
  int  $0x10
  incw %bx
  jmp  DisplayDataIn
DisplayDataOut:
Ret

This function displays each byte of the data from beginning until a null terminated character is encountered.

_boot:
     movw  $0x07c0, %ax       #initialize the data segment
     movw  %ax    , %ds       #to 0x7c00 location
     movw  $0x9000, %ax       #set ax = 0x9000
     movw  %ax    , %es       #set es = 0x9000 = ax
     xorw  %bx    , %bx       #set bx = 0

This is the main boot code for execution. Before we begin with printing the contents of the disk, we set the data segment to 0x7c00 and also set the extended segment to 0x9000.

What is the purpose of setting the extended segment?

First we read a sector into our program memory at 0x9000 and then start displaying the content of the sector.

That is why we set the Extended segment to 0x9000.

mReadSectorFromFloppy $2 #read a sector from floppy disk
call DisplayData         #display the label of the sector
mReadSectorFromFloppy $3 #read 3rd sector from floppy disk
call DisplayData         #display the label of the sector

We call the macro to read sector2 and then display its content and then again we call the macro to read sector 3 and then display its content.

_freeze:                      #infinite loop
jmp _freeze              #

After displaying the contents of the sectors, we go into one infinite loop to hang our program.

_failure:                     #
mPrintString msgFail     #write error message and then
jmp _freeze              #jump to the freezing point

We defined this section to jump to this label incase of any erroneous situations and then hang the program again.

. = _start + 510         #mov to 510th byte from 0 pos
.byte 0x55               #append first part of the boot signature
.byte 0xAA               #append last part of the boot signature

We move to the 510^th byte of the sector and then append the boot signature which is a mandatory for a floppy disk to be identified as a bootable device,
else the system throws an error as invalid disk.

_sector2:                     #second sector of the floppy disk
     .asciz "Sector: 2nr"   #write data to the begining of the sector
     . = _sector2 + 512       #move to the end of the second sector
_sector3:                     #third sector of the floppy disk
     .asciz "Sector: 3nr"   #write data to the begining of the sector
     . = _sector3 + 512       #move to the end of the third sector

The above step performs appending a string at the beginning of the sector 2 and 3.

That’s all for this article

Have fun and try to explore reading floppy disk in real mode and embed the functionality into your bootloader.

In the following articles I will try to brief about File systems and their importance. We will also write a minimal bootloader to parse a fat12 formatted floppy disk,
how to read and write to it and also write a second stage bootloader and its importance.

Bye for now