Результаты поиска по запросу "оперативная система"
Уроки ОСдева №1
В прошлом посте я представил свою операционку и игру, которую пишу под неё в свободное время. Там же я сделал несколько заявок на будущие посты. Среди прочего я сказал, что, возможно, сделаю серию образовательных постов про разработку операционных систем и низкоуровневое программирование. Сегодня будет первый такой пост. Для понимания материала не нужно знать ассемблер или разбираться в устройстве ОС - про всё это я буду рассказывать. Нужно иметь представление об архитектуре компьютера в общих чертах: понимать, что такое BIOS, процессор, материнская плата, оперативная память, видео-, звуковая и сетевая карты, жёсткий диск, оптические и флоппи-приводы и как примерно всё это между собой скрепляется. Неплохо бы знать, что такое бит, байт и слово. Вообще супер, если вы в курсе, чем десятичная система счисления отличается от двоичной и шестнадцатеричной и умеете переводить из одной в другую. Поехали.
P.S.: если знаете английский, советую зайти сюда. Это довольно старая серия уроков по ОСдеву для новичков. Я в своё время почерпнул там очень много и в своих постах наверняка буду невольно цитировать оттуда.
Часть 1, теоретическая.
С чего начать? Вопрос, который возникает в голове любого, кто собрался писать ОС с нуля. В интернете полно тематических ресурсов, но не так много обучающих, где бы задача написания операционной системы разбивалась на небольшие последовательные этапы-уроки. Например, на OSDev.org очень много информации, распределённой по тематическим разделам, но составить на её основе у себя в голове необходимую последовательность действий для новичка будет очень сложно.
Я думаю, стоит начать с включения компьютера. Это не шутка: чтобы создать свою операционную систему, надо до определённой степени понимать как работает компьютер. Что происходит, когда вы нажимаете кнопку POWER на системном блоке и как у вас на экране оказывается ваш заваленный ярлыками и "новыми папками" рабочий стол? Для того, чтобы программа (а наша ОС - это, конечно же, программа) начала исполняться, она должна сначала попасть в оперативную память. Содержимое оперативной памяти же на момент включения пусто. Если среди читающих есть инженеры, советую зажмуриться и пропустить до следующего абзаца: сейчас будет упрощённая модель.
1. Нажатая кнопка POWER посылает электрический сигнал на материнскую плату.
2. Сигнал доходит до материнской платы и отправляется к блоку питания.
3. Блок питания просыпается и начинает подавать энергию подключенным устройствам.
4. Блок питания посылает сигнал на материнскую плату, начинает исполняться программа BIOS.
5. BIOS проводит POST (power-on self-test), посылая сигналы разным устройствам и получая (или не получая) от них ответ. Если устройство не отправило ответ, оно помечается как нерабочее или отсутствующее. Тут же BIOS определяет количество оперативной памяти и некоторые другие параметры системы.
6. Если POST окончен и никаких критических поломок не выявлено, BIOS сверяется со списком загрузочных устройств. Наверняка вы хоть раз его видели, если устанавливали Windows: его обычно можно настроить через интерфейс BIOS, выбрав, с чего загружать ОС (floppy, HDD, USB, ...).
Вот тут начинается часть, которая интересует нас. Предположим, мы вставили дискету с нашей ОС в привод и настроили приоритет загрузки следующим образом: CD-ROM, флоппи-привод, жёсткий диск, USB. Как BIOS определит, что на одном из носителей есть операционная система для загрузки? Физическое устройство цифровых носителей и способы доступа к информации на них это тема для отдельного урока или даже нескольких, так что пока удовольствуемся упрощённой схемой: BIOS считывает с 0 по 511 байты носителя и проверяет, чему равны байты 510 и 511. Если они равны 170 и 85 (AAh и 55h в шестнадцатеричной системе), BIOS считает, что нашёл программу-загрузчик. После этого считанный участок носителя размером в 512 байт загружается в оперативную память и запускается центральный процессор компьютера, который начинает выполнять загруженную программу. Программа-загрузчик догружает остальные файлы ОС и располагает их в памяти нужным образом, а потом говорит процессору, откуда нужно начать выполнение ОС.
Какие выводы можно сделать из полученной информации?
1. Помимо операционной системы на носителе должна быть программа-загрузчик, т.к. компьютер не знает, как именно структурированы файлы ОС и куда их надо загружать. Загрузка ОС - тоже задача разработчика.
2. Загрузчик должен быть не больше 510 байт, ведь BIOS считывает 512 и последние два из них заняты меткой загрузчика.
3. Последние два байта программы-загрузчика должны быть равны AA55h.
3. Загрузчик должен занимать строго определённое место на носителе: с 0 по 511 байты. Думаю, вы замечали, что когда копируете файлы на носитель обычными методами, никто не спрашивает вас, в какой именно участок памяти вы хотите их поместить. Значит, копировать загрузчик нужно каким-то особенным способом.
Это была короткая вводная, но теперь мы имеем представление о том, как операционная система попадает в оперативную память и начинает исполняться при включении компьютера. Предлагаю пока помедитировать над этим. В следующий раз наверное будем говорить об устройстве цифровых носителей и потихоньку погружаться в волшебный мир ассемблера.
Продолжать?
Да
306(59,77%)
Единая Россия
206(40,23%)
Прекращение поддержки Windows 7 грозит проблемами российским банкам
Прекращение технической поддержки операционных систем (ОС) Windows 7 и Windows Server 2008 может стать серьёзной проблемой для российских банков, пишет газета «Коммерсантъ».
Reuters
По словам архитектора технологического центра Microsoft в России Ивана Будылина, теперь они обязаны оперативно перейти на Windows 10, поскольку работа без техподдержки противоречит требованиям информационной безопасности.
При этом проведённый изданием опрос показал, что кредитные учреждения пока не готовы полностью отказаться от старых ОС.
Часть из них рассказали, что договорились о платной дополнительной поддержке Windows 7 (EAS). Однако, пояснил собеседник в Microsoft, это не альтернатива, а временная мера.
В Альфа-банке сообщили, что завершили полный переход. Он продлился около полутора лет и потребовал модернизации парка рабочих станций.
В ВТБ отметили, что на это требуются временные и финансовые затраты. Там, как и в Росбанке, находятся в процессе обновления.
Ранее эксперт по компьютерным технологиям Сергей Корогод в беседе с телеканалом «360» высказал мнение, что прекращение поддержки Windows 7 в первую очередь затронет юридические лица.
Урок ОСдева №4: работа с RAM, адресация в 16-битном режиме, регистры процессора.
Поздравим себя. В прошлый раз мы добавили блок параметров BIOS, после чего винда перестала
ругаться на дискету. Пора начинать писать загрузчик. Но перед этим надо подробнее
разобраться в специфике программирования на ассемблере. Всё-таки он сильно отличается от языков
высокого уровня. Давайте вспомним, как выглядела программа в конце прошлого поста.
.386p
CSEG segment use16
ASSUME cs:CSEG, ds:CSEG, es:CSEG, fs:CSEG, gs:CSEG, ss:CSEG
begin: jmp short execute ;Точка входа. Перейти к исполняемой части.
nop ;Пустой оператор. Заполняет 3-й байт перед BPB.
;БЛОК ПАРАМЕТРОВ BIOS===================================================================;
;=======================================;
;Блок параметров BIOS, 33 байта.
;Здесь хранятся характеристики
;носителя. Должен быть в 3-х байтах
;от начала загрузочного сектора.
;=======================================;
BPB_OEMname db 'BOOTDISK' ;0-7. Имя производителя. Может быть любым.
BPB_bytespersec dw 512 ;8-9. Размер сектора в байтаx.
BPB_secperclust db 1 ;10. Количество секторов в кластере.
BPB_reserved dw 1 ;11-12. Число зарезервированныx секторов (1, загрузочный).
BPB_numFATs db 2 ;13. Число FAT.
BPB_RDentries dw 224 ;14-15. Число записей Корневой Директории.
BPB_sectotal dw 2880 ;16-17. Всего секторов на носителе.
BPB_mediatype db 0F0h ;18. Тип носителя. 0F0 - 3,5-дюймовая дискета с 18 секторами в дорожке.
BPB_FATsize dw 9 ;19-20. Размер FAT в сектораx.
BPB_secpertrack dw 18 ;21-22. Число секторов в дорожке.
BPB_numheads dw 2 ;23-24. Число головок (поверxностей).
BPB_hiddensec dd 0 ;25-28. Число скрытыx секторов перед загрузочным.
BPB_sectotal32 dd 0 ;29-32. Число секторов, если иx больше 65535.
;===============================================;
;Расширенный блок параметров BIOS, 26 байт.
;Этот раздел используется в DOS 4.0.
;===============================================;
EBPB_drivenum db 0 ;0. Номер привода.
EBPB_NTflags db 0 ;1. Флаги в Windows NT. Бит 0 - флаг необxодимости проверки диска.
EBPB_extsign db 29h ;2. Признак расшренного BPB по версии DOS 4.0.
EBPB_volID dd 0 ;3-6. "Серийный номер". Любое случайное число или ноль, без разницы.
EBPB_vollabel db 'BOOTLOADER ' ;7-17. Название диска. Устарело.
EBPB_filesys db 'FAT12 ' ;18-25. Имя файловой системы.
;ИСПОЛНЯЕМЫЙ БЛОК=====================================================================;
execute: cli
hlt
org 1FEh ;Заполняет память нулями до 511-го байта.
dw 0AA55h ;Байты 511 и 512. Признак загрузочного сектора.
CSEG ends
end begin
Я снабдил всё подробными комментариями. Надеюсь, они помогут вам освежить память. Вкратце -
после запуска программы процессор выполняет переход к метке execute - и после этого останавливается
командами cli и hlt. Давайте добавим следующий код после execute, а потом разберём его.
execute: mov ax,07C0h
mov ds,ax
mov es,ax
mov fs,ax
mov gs,ax
cli
mov ss,ax
mov sp,0FFFFh
sti
push ax
mov ax,offset stop
and ax,03FFh
push ax
retf
stop: cli
hlt
org 1FEh ;Заполняет память нулями до 511-го байта.
dw 0AA55h ;Байты 511 и 512. Признак загрузочного сектора.
Целая куча новых команд. Для того, чтобы их понять, придётся освоиться с новыми понятиями.
Регистр - ячейка памяти процессора, которая может выполнять какую-то конкретную задачу
или иметь общее назначение. Программируя на ассемблере, вы постоянно будете оперировать
регистрами: помещать в них данные, извлекать, модифицировать и т.д. В 16-битном режиме
процессор использует следующий набор регистров: AX, BX, CX, DX, SI, DI, BP, SP, flags, CS, DS, ES,
FS, GS, SS. С функциями каждого из них будем разбираться по мере надобности.
Сегмент:смещение - устаревшая система адресации, применявшаяся в эпоху 16-битных процессоров.
Тем не менее, для нас она важна, так как ради обратной совместимости именно в этом
режиме BIOS оставляет систему перед запуском загрузчика.
Постараюсь объяснить. 16-битная разрядность процессора подразумевает, что за раз он может обработать
16 бит данных. Максимальное значение, которое можно передать 16 битами - 65535. Это ограничение
касается и адресации памяти. Выходит, процессору доступно всего (65536/1024) 64 килобайта RAM. Чтобы
обойти это ограничение, была придумана модель адресации segment:offset. Сегмент в ней - это базовый адрес,
от которого считается смещение. Регистры процессора CS, DS, ES, FS, GS и SS - сегментные. Они используются
для указания адреса в памяти, от какого отсчитывается смещение. Например, DS:0050h означает байт 0050h
от значения, помещённого в DS. Вернее, от значения в DS*16. Это называется гранулярностью. Единица,
помещённая в регистр DS, устанавливает основание сегмента не в 1-й байт, а в 16-й. За счёт этого нам
становится доступен целый мегабайт оперативной памяти! (или даже больше с некоторыми ухищрениями,
но рассказывать о них я большого смысла не вижу, т.к. мы всё равно скоро покинем 16-битное царство)
Стек - область памяти, через которую можно передавать параметры процедурам в си-подобных языках
или сохранять состояние регистров при вызове прерывания. В случае ассемблера в стеке можно хранить
промежуточные результаты работы процедуры, если не хватило регистров. Кроме того, стек аппаратно
используется некоторыми командами процессора.
Команда mov op1,op2 используется для того, чтобы переместить значение op2 в op1. В качестве
операнда op1 может выступать адрес ячейки памяти или регистр. В качестве op2 может быть ячейка
памяти, регистр или конкретное значение. Есть два ограничения: операнды должны совпадать по
разрядности (нельзя поместить содержимое 16-битного регистра в 32-битный, например) и в качестве
обоих операндов не могут быть адреса в памяти. Так что делает этот код?
mov ax,07C0h
mov ds,ax
mov es,ax
mov fs,ax
mov gs,ax
Правильно, он помещает значение 07С0h в регистр AX, потом копирует AX в сегментные регистры
DS, ES, FS и GS. Зачем? Затем, что BIOS копирует загрузочный сектор в 07С0h:0000h. Так как
наш загрузчик находится по этому адресу, будет правильным установить значения сегментных регистров
так, чтобы они указывали туда же. По какой-то причине (ей-богу не помню!) присваивать значения
сегментным регистрам напрямую нельзя, но можно через другой регистр - поэтому сначала мы загружаем
его в AX, а уже AX копируем в сегментные регистры. Вы наверое уже обратили внимание, что сегментные
регистры здесь не все. Для модификации оставшихся надо немного поплясать с бубном.
cli
mov ss,ax
mov sp,0FFFFh
sti
Что происходит здесь? Пара команд cli и sti запрещает и разрешает прерывания. Прерывания - то, при помощи
чего разные устройства в компьютере общаются с процессором. Они могут поступать от таймеров, дисковых
контроллеров и из множества других источников. Позже мы ещё поговорим о них подробно, а сейчас достаточно
знать, что команда cli вешает на процессор знак "не беспокоить". sti, соответственно, его снимает.
Дело в том, что SS - это сегментный регистр стека. При манипуляциях с ним лучше убедиться, что в
неподходящий момент не произойдёт переключение задачи. Обратите внимание: сегмент стека у нас там же,
где и загрузчик. Получается, помещая данные в стек, мы затрём часть собственного кода? Нет. Позиция стека
передаётся парой регистров SS:SP. SS - сегмент, а SP - смещение. mov sp, 0FFFFh устанавливает начало
стека в конец сегмента. Получается, ему некуда расти? Тоже нет. Стек растёт в обратном направлении.
Если мы командой push отправим в стек 16-битное слово, то указатель изменит значение на 0FFFDh. Таким
образом, загрузчик и стек находятся в разных концах 64-килобайтного сегмента, и расстояние между ними
вполне приличное.
push ax
mov ax,offset stop
and ax,03FFh
push ax
retf
Соберитесь, последний на сегодня кусок кода. Здесь мы модифицируем сегментный регистр кода, CS. К нему
тоже нужен особый подход. Кстати, самое время поговорить о том, как процессор узнаёт, какую команду выполнять
следующей. Как и в случае стека, существует указатель в виде пары регистров CS:IP. Каждый раз после
считывания из памяти инструкции IP увеличивается на её размер в байтах. Все модели BIOS помещают загрузчик
в 07C0h:0000h, но вот состояние CS:IP может быть разным: например, 07C0h:0000h и 0000h:7C00h указывают на
один и тот же байт в памяти, но во втором случае у нас могут быть проблемы. В каком именно состоянии
оказались регистры CS:IP при старте загрузчика, мы не знаем, поэтому лучше перестраховаться и установить
своё значение.
Как установить значение CS:IP? Например, при помощи инструкции дальнего возврата retf. Обычно она
используется для возврата из процедур, но подойдёт и нам, так кк делает именно то, что нужно: меняет
значения CS:IP. Сегмент и смещение для возврата должны быть в стеке. В AX у нас значение сегмента, 07C0h,
так что командой push отправляем его в стек. А вот с IP придётся повозиться. Щас объясню. CS в данный момент
может быть установлен либо в 07C0h, либо в 0000h. Значит, любое считанное нами смещение относительно его
начала будет равно или X или X+7C00h. Нам нужно однозначно привести его к X. Как это сделать? Команда
mov AX,offset stop помещает в AX смещение метки stop (то есть, конечно, команды cli, сами метки
в исполняемом файле физически не присутствуют и места не занимают). 7С00h, если его перевести в
двоичный вид, будет равно 111110000000000b. Соответственно, искомый X помещается в восьми нулях в начале
значения. обнуление старших пяти единиц будет эквивалентно уменьшению значения на 7С00h, что нам и нужно.
Про логические операции поговорим позже, но пока знайте, что команда and AX,03FFh делает как раз это:
обнуляет все старшие разряды AX, начиная с первой единицы в 111110000000000b. 03FFh, кстати, в
двоичном виде будет выглядеть так: 1111111111b. Заметили связь? В общем, если кто-то не разбирается в
логических операциях, то ДЗ на сегодня - просветиться по этой теме.
Фух, чёрт возьми, на сегодня всё! Теперь наш загрузчик будет работать в предсказуемой среде, что сэкономит
нам море усилий.
Перевод в комментах, кому надо
Отличный комментарий!
![Имя образа Пользо... ЦП Память (... Описание >■
; Бездействие системы система 95" 14^ 516 КБ Процент времени бездействия ... ]
avp.exe система 00 95 403 КБ Kaspersky Anti-Virus
svchost.exe система 00 69 424 КБ Хост-процесс для служб Windows
explorer.exe Админи... 00 28 776 КБ Проводник s](https://img2.joyreactor.cc/pics/post/оперативка-ест-компьютер-2853933.jpeg "оперативка,ест,компьютер,песочница")
Урок ОСдева №7: первичный загрузчик, финал.
В прошлый раз мы написали процедуру загрузки данных и использовали ее для того, чтобы
поместить корневую директорию нашей дискеты в оперативную память сразу после собственно
программы-загрузчика по адресу 07C0h:0200h. План действий на сегодня:
-Найти в КД номер первого кластера файла.
-Загрузить первый кластер.
-Следуя по цепочке записей в FAT, загрузить остальные кластеры.
Перед тем, как кодить дальше, давайте разберёмся, что такое КД и как её использовать для
поиска файлов*.
По сути корневая директория в FAT12 - это таблица, в которой каждому файлу или
поддиректории соответствует одна 32-байтная запись. Давайте посмотрим, что в ней есть.
Байты 0-10: имя файла в формате 8:3. Этот формат подразумевает, что имя файла занимает
ровно 8 байтов, а расширение - 3. Если имя файла меньше 8 символов, оно дополняется
пробелами: так, файл 'loader.bin' в КД будет проходить под именем 'LOADER BIN'.
Байт 11: атрибуты записи. Набор флагов, позволяющий придать записи особые свойства.
00000001b = только для чтения
00000010b = скрытый
00000100b = системный
00001000b = метка раздела
00010000b = директория
00100000b = архив
00001111b = LFN (long file name), запись имеет особый формат, поддерживающий длинные
имена файлов.
Байт 12: зарезервирован для Windows NT.
Байт 13: время создания в десятых секунды (почему-то 0-199 согласно OSDev Wiki).
Байты 14-15: время, когда был создан файл. Младшие 5 бит - секунды/2 (то есть при интерпретации
значения, например, для вывода на экран, эту часть надо умножать на 2). Следующие 6 - минуты.
Последние 5 бит - часы.
Байты 16-17: дата создания файла. Примерно та же история. День(0-4), месяц(5-8), год(9-15).
Байты 18-19: дата последнего доступа в том же формате, что и дата создания.
Байты 20-21: старшие 16 бит номера первого кластера файла. В FAT12 и FAT16 не используется.
Байты 22-23: время последнего изменения в том же формате, что и время, когда был создан файл.
Байты 24-25: дата последнего изменения в том же формате, что и дата создания.
Байты 26-27: младшие 16 бит номера первого кластера файла.
Байты 28-31: размер файла в байтах.
Довольно много информации, но нас интересуют только два поля: имя записи и младшая часть номера
стартового кластера (старшая половина в FAT12 не используется). Вырисовывается в общих чертах
алгоритм поиска файла? Если нет, я помогу:
1. Переходим к началу КД
2. Считываем имя записи
3. Сравниваем имя записи с именем искомого файла
4. Если имена совпали, файл найден, SUCCESS!
5. Записи кончились?
6. Если кончились - файла нет, аварийно завершаемся
7. Переходим к следующей записи
8. goto 2
Вот таким нехитрым способом мы сможем найти на диске начало файла или, если его нет, уведомить
об этом пользователя и свернуть выполнение загрузчика. Я решил, начиная с этого поста, не
перепечатывать весь листинг из предыдущих уроков. Вместо этого я приложу ссылку на файл в
конце. Это позволит вместить в пост больше полезной информации, не растягивая его до
нечитабельных размеров. А теперь давайте выполним наш поисковый алгоритм в коде. После
call read_sectors пишите:
mov cx,BPB_RDentries
mov di,0200h
mov si,offset fname
mov bp,si
next_entry: mov ax,cx
mov bx,di
mov cx,11
rep cmpsb
mov si,bp
mov di,bx
mov cx,ax
je load_FAT
add di,32
loop next_entry
mov ah,3
xor bh,bh
int 10h
mov ax,1300h
mov bx,0007h
mov cx,22
mov bp,offset fname
int 10h
cli
hlt
Что всё это значит? В строчке mov cx,BPB_RDentries мы устанавливаем счётчик основного
цикла. Напоминаю, что в переменной BPB_RDentries у нас хранится число записей корневой
директории. 0200h - смещение загруженной в RAM КД. В SI мы помещаем смещение строки с
именем искомого файла. Кстати, впишите в переменные fname db 'LOADER BIN'. После этого
мы сохраняем это же смещение в регистре BP. Это может быть пока неочевидно, но позже вы
поймёте, зачем.
Следующий блок кода, начинающийся с метки next_entry, - это собственно цикл просмотра
записей КД и сравнения имён. Первым делом мы сохраняем счётчик цикла и смещение текущей
записи. Счётчик сохраняем потому, что будет вложенный цикл, а смещение - потому, что
строковые инструкции вроде cmpsb изменяют значения регистров SI и DI. Кстати, теперь вам
должно быть понятно, зачем мы сохраняли указатель на строку с именем в BP.
mov cx,11 - установка счётчика вложенного цикла. Имена в FAT12 хранятся в формате 8:3,
значит, нам нужно сравнить две строки по 11 символов. Надеюсь, тут вопросов нет?
Инструкция cmpsb сравнивает значения двух байтов (в нашем случае символов), находящихся
в DS:SI и ES:DI. Префикс rep повторяет инструкцию, пока не обнулится счётчик в CX.
Далее мы восстанавливаем счётчик основного цикла в CX, смещение текущей записи в DI и
смещение строки с именем файла в SI. В старых версиях здесь у меня были пары инструкций
push/pop, но потом я подумал, что трансфер из регистра в регистр быстрее, чем обращение
к стеку, и поменял. Никогда не вредно сэкономить пару циклов.
Если в результате rep cmpsb все символы совпали, в регистре флагов будет установлен бит
ZF. Команда je load_FAT выполняет переход к метке load_FAT если флаг ZF установлен.
В случае если строки не совпали, мы переводим DI к следующей записи в КД и продолжаем
цикл командой loop next_entry. Тут бы можно было и закончить, но нужно обработать
отсутствие файла. С этим набором инструкций мы уже знакомы по предыдущему посту.
Первый блок возвращает положение курсора в DH,DL, а второй выводит от этой позиции
сообщение. Отличается только само сообщение. Вместо 'Disk read error.' мы выводим строку
с именем файла. Внимание, тут небольшой хак. Идея в том, чтобы вывести следующий текст:
'{filename} not found!'. Вызвать вывод строки два раза, но зачем? Если поместить в
разделе переменных текст ' not found!' сразу после переменной fname, а при вызове int 10h
указать в CX не 11 символов, а 22, то выведется сначала имя файла, а потом ' not found!'
Конечно же, этот текст обязательно должен быть сразу после fname. Добавьте строчкой ниже
db ' not found!' После этого останавливаем процессор парой команд cli и hlt. Не так-то
сложно, да? Впрочем, файл ещё нужно загрузить.
Для этого нам нужно будет загрузить в память FAT и разобраться, как ею пользоваться.
Давайте начнём с первой задачи, она чисто техническая и не требует умственного напряжения.
После hlt набирайте:
Load_FAT: mov ax,[di+26]
mov cluster,ax
mov ax,BPB_reserved
mov cx,total_FATs_size
mov bx,BPB_RDentries
shl bx,5
add bx,0200h
mov FAT_offset,bx
call read_sectors
В строчке mov ax,[di+26] мы считываем из записи КД номер первого кластера файла, а затем
сохраняем его в переменной cluster. Далее, мы помним, что FAT у нас идут сразу после
зарезервированных секторов, поэтому в AX помещаем BPB_reserved. В CX у нас будет число
секторов, которое надо загрузить, то есть total_FATs_size. Загружать FAT будем сразу после
КД, то есть в 07С0h:0200h+размер КД. Размер КД = число записей КД*размер записи (32 байта).
Помещаем в BX число записей (BPB_RDentries), умножаем на 32 (shl bx,5 эквивалентно умножению
на 32, но выполняется быстрее) и добавляем 0200h. Готово! Сохраняем на будущее в переменной
FAT_offset (кстати, объявите её рядом с прочими) и вызываем read_sectors.
А теперь время вернуться к теории. Что такое FAT? Не поверите, но это тоже таблица, и её
структура ещё проще, чем у КД. Каждая запись в FAT соответствует кластеру на диске. FAT
можно назвать оглавлением диска (украл с OSDev Wiki). Кластер может быть свободен, занят
частью файла, зарезервирован ОС или испорчен. Если кластер хранит часть файла, то его
запись в FAT будет содержать номер следующего кластера файла. Понятно? Зная номер первого
кластера файла, мы можем загрузить его в память, потом заглянуть в FAT, найти нужную запись
и считать номер следующего кластера. Повторять до конца файла. Звучит просто, но, как
всегда, есть большое "НО"! Размер записи в FAT12 - 12 бит. Мы не можем оперировать
12-битными ячейками. Мы можем считать 8 или 16. То есть, если мы загрузим в AX начало FAT,
то в регистре окажется первая запись и часть второй. А если сдвинемся на один байт, то
получим конец первой записи и всю вторую. Давайте попробую проиллюстрировать для
наглядности. В верхней строчке будет часть FAT, разделённая на записи, а в нижней она же,
но поделенная на 8-битные куски.
0 0 0 1 0 1 1 1 0 0 1 0|0 1 1 1 0 0 1 0 1 0 0 0|0 0 1 0 0 1 0 0 0 1 1 1 3 Записи.
0 0 0 1 0 1 1 1|0 0 1 0 0 1 1 1|0 0 1 0 1 0 0 0|0 0 1 0 0 1 0 0|0 1 1 1 4,5 байта.
Решение в том, чтобы, считывая каждый нечётный кластер, сдвигать значение на 4 бита вправо, а
у чётного - обнулять 4 старших бита. Зная всё это, давайте писать код:
push 0050h
pop es
xor bx,bx
read_cluster: mov ax,cluster
sub ax,2
movzx cx,BPB_secperclust
mul cx
add ax,datasector
call read_sectors
mov ax,cluster
mov si,ax
shr ax,1
add si,ax
add si,FAT_offset
mov dx,[si]
mov ax,cluster
test ax,1
jnz odd_cluster
and dx,0000111111111111b
jmp short done
odd_cluster: shr dx,4
done: mov cluster,dx
cmp dx,0FF7h
jb read_cluster
Финальный рывок. Первое, что мы делаем - устанавливаем сегмент для загрузки файла. Так как
BIOS нам больше не указ, выбирать можно самостоятельно. Я бы с удовольствием отправил его
в 0000h:0000h, но первые 1280 байт заняты важными вещами, о которых поговорим позже.
Ближайший свободный участок RAM - 0050h:0000h (или 0000h:0500h, это тот же самый адрес
если вы вдруг забыли правила адресации сегмент:смещение). Обнуляем BX, так чтобы пара
ES:BX указывала на 0050h:0000h. Считываем в AX номер первого кластера файла. Дальше мы
вычитаем 2 из этого номера. Зачем? Затем, что значения 0 и 1 в FAT зарезервированы и не
используются в качестве номеров, а номер, указанный в таблицах, на 2 больше, чем правильное
значение. Да, это идиотизм.
Загружать будем не сектор, а кластер (что в нашем случае одно и то же, но всё-таки),
поэтому в качестве числа секторов помещаем в CX переменную BPB_secperclust и на неё же
умножаем номер кластера. AX*CX в данном случае дадут нам номер первого сектора нужного
кластера. А так как кластеры в FAT начинают считаться от начала области данных,то для
абсолютного значения добавляем к AX datasector. Готово. Вызываем read_sectors и загружаем
первый кластер файла в RAM.
Дальше будет немножко математической магии, объяснять которую я не буду. Если интересно -
разберётесь самостоятельно, там не так сложно. Остальным предлагаю просто поверить, что
смещение записи кластера внутри FAT = 3/2 номера кластера. Значит, берём в AX номер
кластера, его же помещаем в SI, делим AX на 2 и прибавляем к SI. Вуаля, смещение
записи от начала FAT найдено. Добавляем к нему смещение FAT_offset и считываем в DX
значение записи.
Теперь надо проверить, чётная ли запись. Для этого опять берём в AX номер кластера и
делаем сравнение с 1. Если флаг ZF не установлен (то есть 0 бит значения равен 1),
значит, номер записи - нечётный, переходим к odd_cluster и сдвигаем значение вправо на
4 позиции. Если чётный - делаем логическое "И" с маской 0000111111111111b и обнуляем
тем самым 4 старших бита. Теперь у нас есть содержимое нужной записи без всяких
посторонних хвостов, то есть номер следующего кластера. Сохраняем его в переменной
cluster. Дальше у нас идёт сравнение с номера с числом 0FF7h. Дело в том, что,
начиная от этого значения в FAT идут специальные коды, которые могут означать конец
файла, испорченный сектор и т.д. Для нас это значит, что если в качестве номера
кластера мы получили 0FF7h или больше, продолжать загрузку не имеет смысла. Поэтому
продолжаем цикл только если DX меньше 0FF7h. Я умышленно оставляю здесь дыру и
предлагаю всем заинтересованным попытаться самостоятельно сделать обработку ошибки,
связанной с битым кластером (код 0FF7h). Код конца файла, кстати, 0FF8h. Вся необходимая
для этой задачи информация и примеры кода уже есть в этом посте.
А мне остаётся только добавить в конце три строчки:
push 0050h
push 0000h
retf
Этот набор команд мы уже помним из старых постов. Помещаем в стек сегмент, потом
смещение, и передаём управление загруженному файлу командой retf. Поздравим себя!
Первичный загрузчик готов. Да, он умеет немного, но и задача у него всего одна:
найти загрузчик второго уровня, поместить его в RAM и отдать штурвал. Если вы
скомпилируете файл без инструкций org 1FEh и dw 0AA55h, то увидите, что программа
занимает всего 447 байт. Значит, у нас есть в запасе ещё 63. Как раз должно
хватить на проверку успешного считывания кластеров. У меня вместе с ней вышло 497
байт. Можете подсмотреть в приложенном файле, хоть это и неспортивно. Если вы
поместили загрузчик на дискету и получили в bochs (или на реальной машине) вот такой
экран, то всё работает как надо!
Чистая дискета:
https://drive.google.com/file/d/1Bold4ds8oEruHQ7fJZKHglVo7A2Vc5MR/view?usp=sharing
Листинг:
https://drive.google.com/file/d/1Q5EtKX5kyF4MWcBeD8a6Jz5cPtqZja9C/view?usp=sharing
Bochs:
https://drive.google.com/file/d/16k2Gpr7oPSekq4rAhmtBV0IPnIteDLlE/view?usp=sharing
* FAT поддерживает вложенные директории, и они ничем принципиально не отличаются
от корневой, так что всё нижеизложенное касается и их.
Здесь мы собираем самые интересные картинки, арты, комиксы, мемасики по теме оперативная система (+1000 постов - оперативная система)
Хорошо, ставь.
Для установки 6-ти зависимостей вам нужно установить 139 предыдущих зависимостей
Хорошо, ставь.
Линукс: установить хуйня-1.24 невозможно так как у вас уже установлена новая версия новая0хуйня-4.23, но это не удовлетворяет зависимость так как 25-ти летнее ПО не знает о "новая0хуйня"