Как сделать свою операционную систему на компьютер

Что нужно знать, чтобы написать операционную систему

Что нужно знать, чтобы написать операционную систему

• Переводы, 2 августа 2019 в 15:11
• Александр Ланский

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

Что такое ОС

Операционная система (ОС) — это программное обеспечение, которое работает с компьютерным железом и его ресурсами и является мостом между аппаратной и программной частью компьютера.

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

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

ОС предоставляет всё необходимое для работы пользовательских программ. Их появление означало, что теперь программам не нужно контролировать весь объём работ компьютера (это отличный пример инкапсуляции). Теперь программам нужно было работать именно с операционной системой, а система уже сама заботилась о ресурсах и работе с периферией (клавиатура, принтер).

Кратко об истории операционных систем

Первая операционная система была создана в 1956 году компанией General Motors для единственного компьютера IBM. Остальные владельцы этих компьютеров последовали примеру и начали создавать собственные ОС.

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

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

В эти же годы компании Control Data Corporation, Computer Sciences Corporation, Burroughs Corporation, GE, Digital Equipment Corporation и Xerox тоже начали реализовывать свои ОС.

В конце 60-х была разработана первая версия ОС Unix. Написанная на Си, свободно доступная первые годы, Unix привлекала всё больше внимания и аудитории. Она легко портировалась на новые системы и начала набирать обороты.

Многие современные ОС, включая Apple OS X и все разновидности Linux-систем, являются дальними потомками Unix.

Microsoft Windows, в свою очередь, была написана для ряда персональных компьютеров IBM.

Первая ОС от Microsoft называлась не Windows, а MS-DOS. Эта система была создана в 1981 году, когда систему 86-DOS купили у компании Seattle Computer Products и модифицировали её под требования IBM.

Всем привычное название Windows появилось в 1985, когда MS-DOS обзавелась графическим интерфейсом.

Apple OS X, Microsoft Windows и ряд Linux-систем (включая Android) сейчас контролируют большую часть рынка операционных систем.

Составляющие операционной системы

ОС состоит из двух основных частей:

• ядро системы;
• системные программы.

Ядро (англ. kernel)

Сердце операционной системы. Именно оно запускается первым при включении компьютера (не считая BIOS и загрузчик). Ядро контролирует ресурсы компьютера и обрабатывает запросы от системных программ.

Системные программы

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

Пользовательские программы

Не являются частью операционной системы. Именно эти программы уже имеют конкретное назначение. Текстовые редакторы, браузеры, медиа-плееры — всё это пользовательские программы. Они контролируются ядром и используют системные программы для доступа к периферии.

Что необходимо знать

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

• базовое понимание компьютерной науки (информатики);
• теория и опыт в программировании;
• знание высоко- и низкоуровневых языков программирования.

Изучение информатики

Разработка ОС — это не тоже самое, что, скажем, веб-разработка. Тут нельзя будет просто и быстро разобраться в базовых вещах. Для начала нужно получить крепкий базис информатики и только потом переходить к другим темам.

Coursera: Computer Science 101 — это курс, который подойдёт для тех, кто только начал осваиваться в информатике и программировании. Если у вас уже имеются элементарные знания в в этой области, то пропустите этот курс и переходите к следующему.

Udacity: Intro to Computer Science использует веб-разработку в качестве подхода к обучению компьютерной науке. Хоть курс и не направлен на непосредственную разработку ОС, он даёт мощный базис в области программирования.

edX: Introduction to Computer Science — этот курс является самым исчерпывающим и углублённым в этом списке. Несмотря на это, он полностью бесплатен. Курс был разработан в Гарвардском Университете. В нём вас научат алгоритмам, структурам данных, управлению ресурсами, разработке ПО, а так же познакомят с такими языками программирования, как C, PHP и JavaScript.

Подборка книг для самостоятельного изучения Computer Science.

Изучение программирования

С крепкими знаниями в области информатики и хотя бы базовым пониманием программирования вам нужно набраться опыта в разработке проектов.

Udacity: Software Development Process — отличный курс для тех, кто ещё не принимал участие в крупных проектах. Тут вас ознакомят с подробностями рабочего процесса и работой с инструментарием (например Git), а также расскажут о настройке интегрированной среды разработки.

Изучение языков программирования

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

• низкоуровневый язык ассемблера;
• высокоуровневый язык программирования.

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

Высокоуровневые языки программирования, в свою очередь, работают сразу на нескольких архитектурах. Самый популярный из таких языков — Cи. Чаще всего именно на нём и пишутся операционные системы. Но это не означает, что этот язык единственный. Для написания ОС можно использовать и более высокоуровневые языки, например C++ или Python.

Прим. перев. Есть пример написания «игрушечных» операционных систем на C#. Cosmos — некий конструктор ОС. В этой статье на практическом примере показывают написание системы всего в нескольких десятках строк.

Язык ассемблера для x86

«x86 Assembly Guide» — неплохо подойдёт для начального изучения ассемблера. Несмотря на то, что эта статья коротка для полного курса, в ней содержится всё необходимое для дальнейшего углубления.

Книга «Programming from the Ground Up» Джонатана Бартлетта является одной из основных по изучению ассемблера. В ней основами языка программирования подкрепляются базисы информатики.

Для изучения ассемблера есть ещё одна показательная книга — «The Art of Assembly Language», написанная Рэнди Гайдом. Изначально книга писалась специально для курсов, которые вёл автор в Калифорнийском университете Cal Poly и UC Riverside. В середине 90-х годов книга была признана определяющей в этой сфере.

Если вдруг вышеописанные материалы вам не подошли, вот ещё пара отличных книг:

Язык Cи

Как уже упоминалось выше, для написания ОС есть несколько высокоуровневых языков программирования. Однако самый популярный из них — Си.

Начать изучать этот язык можно отсюда. Этот ресурс ознакомит вас с базовыми понятиями и подготовит к более сложным задачам.

«Learn C the Hard Way» — название ещё одной книги. Кроме привычной теории в ней собрано много практических решений. Этот учебник расскажет обо всех аспектах языка.

Либо же можете выбрать одну из этих книг:

Разработка ОС

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

«Linux From Scratch». Здесь рассматривается процесс сборки операционной системы Linux (учебник переведён на много языков, в том числе и на русский). Тут, как и в остальных учебниках, вам предоставят все необходимые базовые знания. Полагаясь на них можно попробовать себя в создании ОС. Чтобы сделать программную часть ОС более профессиональной, присутствуют дополнения к учебнику: «Beyond Linux from Scratch», «Automated Linux from Scratch», «Cross Linux from Scratch» или «Hardened Linux from Scratch».

«The little book about OS development» Эрика Хэйлина и Адама Ренберга. Этот учебник разработан в рамках продвинутого курса информатики и на момент его написания авторы являлись студентами Королевского Института Технологий в Стокгольме. В этой книге рассматривается разработка ОС для архитектуры x86 (причём с самого начала — с установки среды разработки). В этом курсе рассказывается о многих интересных темах, включая многозадачность, управление памятью и разработку файловой системы.

«Operation System Development Series» Broken Thorn Entertainment — серия из 25 уроков, посвящённых разработке ОС с нуля.

Примечание Эти уроки рассчитаны на то, что вы уже знакомы с IDE и владеете как языком ассемблера, так и Cи.

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

Сообщества, посвященные разработке ОС

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

• OSDev.org — это Вики с исчерпывающей информацией о разработке ОС и отличным форумом, где вы можете попросить о помощи или же наоборот сами кого-нибудь выручить.
• OS Development Channel на Реддите. Канал, также посвящённый разработке ОС.
• Computer Science, Programmers, StackOverflow от StackExchange — площадки, где вы можете задавать различные технические вопросы.

Заключение

Обучение разработке ОС — достаточно сложная задача. Однако в процессе вы разберётесь в работе процессора и аппаратного уровня, что поможет лучше понимать работу и оптимизацию высокоуровневых приложений и их взаимодействие друг с другом. Ну и в глазах коллег вы наверняка будете выглядеть очень крутым (но это не точно).

Как сделать свою операционную систему на компьютер

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Первое ядро

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

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

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

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

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

Сборка ядра

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Пишем операционную системы своими руками

Информация о работе

Узнать стоимость работы

Заполнение формы не обязывает Вас к заказу работы

Скачать файл с работой

Помогла работа? Поделись ссылкой

Не давно мне стало интересно на сколько тяжело написать операционную систему, как она вообще устроенна внутри, что должна делать, ну или хотя бы какой минимальный набор функциональности иметь. Так же было интересно низкоуровневое программирование, там где нет помощников и готовых функций, только ты, железо и BIOS, без него было бы совсем туго : ). И я решил написать простенькую ОС а попутно подучить уже совсем забытый мной ассемблер, и архитектуру x86.

Первое что я решил заделать это поискать статьи, типа «Пишем простую ОС». Таковых оказалось довольно много но лично я смог уловить по ним только основной принцип написания ОС, довольно поверхностно. Возможно просто мой уровень IQ маловат, хотя признаться я его не когда не измерял, боюсь результата : ). Ну так вот открыв кучу вкладок в своём браузере, а также различных исходников ОС в notepad++ я принялся за дело. Ниже я опишу всё что я выяснил о создании собственной ОС.

Загрузка ОС с дискеты

Нашу ОС мы разместим на дискете, по этому давайте рассмотрим процесс загрузки операционной системы с дискеты. Он состоит из нескольких этапов, сначала загружается BIOS ( англ. basic input/output system — «базовая система ввода-вывода»), затем BIOS определяет различные устройства в том числе и блочные устройства ввода-вывода, К блочным относятся такие устройства, которые хранят информацию в блоках фиксированной длины, у каждого из которых есть свой собственный адрес. Обычно размеры блоков варьируются от 512 до 32 768 байт. Вся передача данных ведется пакетами из одного или нескольких целых (последовательных) блоков. Важным свойством блочного устройства является то, что оно способно читать или записывать каждый блок независимо от всех других блоков. Среди наиболее распространенных блочных устройств жесткие диски, приводы гибких дисков а так же, приводы компакт-дисков и флэш-накопители USB. Нас же интересуют приводы гибких дисков а именно привод для дискет диаметром 3.5 дюйма и объёмом 1.4МБ(1 474 560 байт)

Немного об устройстве привода. Привод состоит из электронной части и механической, в механической части присутствуют два двигателя, один из них шаговый, шаговым его называют по тому что он вращается не непрерывно, как обычные двигатели, а маленькими точными шагами, шаг двигателя 3.5 дюймового дисковода равен 1,8 °, что позволяет с его помощью довольно точно позиционировать головку записи-чтения над определённой областью магнитного диска дискеты. Также к механической части относятся головки чтения-записи они то и считывают-записывают данные на магнитный диск. Их в дисководе две, одна над магнитным диском другая под ним. Ниже показано размещение головок над диском.

Д
иск имеет магнитное покрытие и разбит на дорожки и сектора, на одной стороне диска содержится 80 дорожек, всего сторон две, нумерация дорожек начинается с 0 по 79, в одной дорожке содержится 18 секторов, емкость одного сектора составляет 512байт. Нумерация секторов начинается с первого. Первый сектор является загрузочным

После определения всех устройств BIOS начинает загрузку с накопителя который выбран как загрузочный. На этом накопителе должен присутствовать загрузочный сектор в котором находится программа загрузки ядра ОС. После чего BIOS прочтёт первый сектор диска, который как правило является загрузочным и если найдёт на нём сигнатуру загрузочного сектора, это два последних байта сектора, имеющие вид в шестнадцатеричной системе AA h, 55 h, то загрузит этот сектор в оперативную память по адресу 07C00h, и передаст управление загруженному коду. Далее этот код должен загрузить ядро ОС в память и передать ему управление.

У меня нет ни дискеты ни дисковода, да и писать любую программу куда приятнее если есть возможность запускать её по сто раз за час, дабы убедится в работе каждой написанной строчки кода :). По этому воспользуемся виртуальной машиной, я выбрал Virtual Box. Скачать Virtual Box можно тут https://www.virtualbox.org/ . Моя версия 5.0.0 на Windows 7 64 бит, сразу работать не захотела, порыскав на форумах, оказалось проблема заключается в том, что у многих для установки расширенных тем оформления пропатчен фал Windowssystem32 uxtheme. dll . Обычно оригинальный файл находится в том же каталоге и имеет имя uxtheme. dll.backup. Просто поменяйте между собой их названия.

Далее нам понадобится компилятор FASM ( flat assembler ) – это с вободно распространяемый многопроходной ассемблер , написанный Томашем Грыштаром ( польск. Tomasz Grysztar ). Скачать его можно с официального сайта https://flatassembler.net/ . Писать код мы будем в Notepad++ его скачать можно тут https://notepad-plus-plus.org/ . Установите FASM в корневой каталог диска C, затем установите Notepad++.

Также нам понадобится программа способная создать виртуальный образ дискеты, для этих целей я написал на C# простенькую программку, которую назвал imgMaster. Принцып её действия довольно прост, после запуска программы, нажимаем кнопку Add File, и выбираем первый файл, его размер должен составлять 512байт не больше, не меньше, не больше так как он может не поместится в загрузочный сектор размер которого, как мы уже знаем 512байт. А не меньше по тому что 511 и 512 байты, это сигнатура загрузочного сектора, без них BIOS решит что программа загрузчик отсутствует, и не станет не чего загружать из сектора. Далее при необходимости добавляем остальные файлы, и нажимаем Create IMG, сохраняем образ. Программа запишет файлы один за другим, в той же очерёдности в которой они расположены в списке, затем оставшееся место заполнит нулями, чтобы размер образа был равен ёмкости дискеты 1.4МБ(1 474 560 байт).

Можно приступать к написанию первой тестовой программы, которая без операционной системы, будет способна вывести на экран традиционную надпись «Hello World!».

И так первое что нам необходимо сделать это узнать где мы будем находится в ОЗУ. Ниже представлена модель адресного пространства ОЗУ, как я её понял.

Источники:

https://tproger.ru/translations/what-you-should-know-to-create-os/
https://subscribe.ru/archive/comp.soft.myosdev/201207/16191615.html
https://www.sesiya.ru/staty/programmirovanie/1679-pishem-operacionnuyu-sistemy-svoimi-rukami/