Как сделать операционную систему в visual studio
В этом пошаговом руководстве показано, как создать традиционное классическое приложение Windows в Visual Studio. В примере приложения, которое вы создадите, используется API Windows для отображения "Hello, Windows desktop!" в окне. Код, созданный в этом пошаговом руководстве, можно использовать в качестве шаблона для создания других классических приложений Windows.
Для краткости некоторые операторы кода опущены в тексте. В разделе "Сборка кода" в конце этого документа показан полный код.
Предварительные требования
Компьютер под управлением Microsoft Windows 7 или более поздних версий. Мы рекомендуем Windows 10 или более поздней версии для оптимальной разработки.
Копия Visual Studio. Сведения о скачивании и установке Visual Studio см. в этой статье. Когда вы запускаете установщик, убедитесь, что установлена рабочая нагрузка Разработка классических приложений на C++ . Не беспокойтесь, если вы не установили эту рабочую нагрузку при установке Visual Studio. Вы можете снова запустить установщик и установить ее сейчас.
Базовые значения об использовании интегрированной среды разработки Visual Studio. Если вы уже использовали классические приложения для Windows, вы, вероятно, справитесь. Общие сведения см. в обзоре возможностей интегрированной среды разработки Visual Studio.
Основные навыки владения языком C++. Не волнуйтесь, мы не будем делать ничего сложного.
Создание классического проекта Windows
Выполните следующие действия, чтобы создать свой первый Windows классический проект. По мере использования вы введете код для рабочего Windows классического приложения. Чтобы ознакомиться с документацией по предпочтительной версии Visual Studio, используйте селектор Версия. Он находится в верхней части оглавления на этой странице.
Создание классического проекта Windows в Visual Studio
В главном меню выберите Файл >Создать >Проект, чтобы открыть диалоговое окно Создание проекта.
В верхней части диалогового окна задайте языкC++, задайте для платформызначение Windows и задайте для Project тип "Рабочий стол".
В отфильтрованный список типов проектов выберите Windows мастер рабочего стола и нажмите кнопку "Далее". На следующей странице введите имя проекта, например DesktopApp.
В Обозреватель решений щелкните правой кнопкой мыши проект DesktopApp, выберите "Добавить" и выберите "Создать элемент".
В диалоговом окне Добавление нового элемента выберите Файл C++ (.cpp). В поле "Имя" введите имя файла, например HelloWindowsDesktop.cpp. Выберите Добавить.
Теперь проект создан, и исходный файл откроется в редакторе. Чтобы продолжить, перейдите к созданию кода.
Создание классического проекта Windows в Visual Studio 2017 г.
В меню Файл выберите команду Создать, а затем пункт Проект.
В диалоговом окне "Создать Project" в области слева разверните узел InstalledVisual>C++, а затем выберите Windows Desktop. В средней области выберите мастер Windows рабочего стола.
В Обозреватель решений щелкните правой кнопкой мыши проект DesktopApp, выберите "Добавить" и выберите "Создать элемент".
В диалоговом окне Добавление нового элемента выберите Файл C++ (.cpp). В поле "Имя" введите имя файла, например HelloWindowsDesktop.cpp. Выберите Добавить.
Теперь проект создан, и исходный файл откроется в редакторе. Чтобы продолжить, перейдите к созданию кода.
Создание классического проекта Windows в Visual Studio 2015 г.
В меню Файл выберите команду Создать, а затем пункт Проект.
В диалоговом окне "Создать Project" в области слева разверните узел InstalledTemplatesVisual> >C++, а затем выберите Win32. В средней области выберите шаблон Проект Win32.
На странице "Обзор " мастера приложений Win32 нажмите кнопку "Далее".
На странице "Приложение Параметры" в разделе "Тип приложения" выберите Windows приложение. В разделе "Дополнительные параметры" снимите флажок предварительно скомпилированного заголовка, а затем выберите " Пустой проект". Чтобы создать проект, нажмите кнопку Готово.
В Обозреватель решений щелкните правой кнопкой мыши проект DesktopApp, выберите "Добавить" и выберите "Создать элемент".
В диалоговом окне Добавление нового элемента выберите Файл C++ (.cpp). В поле "Имя" введите имя файла, например HelloWindowsDesktop.cpp. Выберите Добавить.
Теперь проект создан, и исходный файл откроется в редакторе.
Создание кода
Далее вы узнаете, как создать код для классического приложения Windows в Visual Studio.
Запуск классического приложения Windows
Так же, как каждое приложение C и приложение C++ должны иметь функцию в качестве отправной main точки, каждое Windows классическое приложение должно иметь WinMain функцию. WinMain имеет следующий синтаксис:
Сведения о параметрах и возвращаемых значениях этой функции см. в разделе "Точка входа WinMain".
Что такое все эти дополнительные слова, такие как WINAPI , или CALLBACK , или, или HINSTANCE , или _In_ ? Традиционный API Windows использует методы typedefs и макросы препроцессора для абстрагирования некоторых подробностей типов и кода для конкретной платформы, таких как соглашения о вызовах, __declspec объявления и прагмы компилятора. В Visual Studio можно использовать функцию быстрой информации IntelliSense, чтобы узнать, что определяют эти определения типов и макросов. Наведите указатель мыши на интересующее слово или нажмите клавиши CTRLK, CTRLI++ для небольшого всплывающего окна, содержащего определение. Дополнительные сведения см. в разделе Using IntelliSense. Параметры и типы возвращаемых значений часто используют заметки SAL для перехвата ошибок программирования. Дополнительные сведения см. в статье "Использование заметок SAL для уменьшения дефектов кода C/C++".
Windows требуются классические программы. TCHAR определяет макрос, который разрешается в конечном счете wchar_t , если символ ЮНИКОД определен в проекте, в противном случае он разрешается в char . Если вы всегда создаете сборку с поддержкой ЮНИКОДа, вам не требуется TCHAR и может использоваться напрямую wchar_t .
Наряду с функцией WinMain каждый Windows классическое приложение также должно иметь функцию window-procedure. Обычно эта функция называется WndProc , но ее можно присвоить любое имя. WndProc имеет следующий синтаксис:
Дополнительные сведения см. в разделе Процедуры окна.
Добавление функциональных возможностей в функцию WinMain
WinMain В функции вы заполняете структуру типа WNDCLASSEX. Структура содержит сведения о окне: значок приложения, цвет фона окна, имя, отображаемое в заголовке строки, помимо прочего. Важно отметить, что он содержит указатель функции на процедуру окна. В приведенном ниже примере показана типичная структура WNDCLASSEX .
Сведения о полях приведенной выше структуры см. в разделе WNDCLASSEX.
Теперь можно создать окно. Используйте функцию CreateWindowEx .
Эта функция возвращает HWND дескриптор окна. Дескриптор немного похож на указатель, который Windows используется для отслеживания открытых окон. Дополнительные сведения см. в разделе Типы данных Windows.
На этом этапе окно было создано, но нам все равно нужно сообщить Windows, чтобы сделать его видимым. Вот что делает этот код:
На этом этапе функция WinMain должна напоминать приведенный ниже код.
Добавление функциональных возможностей в функцию WndProc
HDC в коде — это дескриптор контекста устройства, который используется для рисования в клиентской области окна. Используйте функции для EndPaint подготовки BeginPaint и завершения рисования в клиентской области. BeginPaint возвращает дескриптор контексту устройства отображения, используемому для рисования в клиентской области; EndPaint завершает запрос на рисование и освобождает контекст устройства.
Сборка кода
Как и было обещано, ниже приведен полный код для рабочего приложения.
Сборка примера
Удалите любой код, введенный в HelloWindowsDesktop.cpp в редакторе. Скопируйте этот пример кода и вставьте его в HelloWindowsDesktop.cpp:
В меню Построение выберите Построить решение. Результаты компиляции должны отображаться в окне вывода в Visual Studio.
Чтобы запустить приложение, нажмите клавишу F5. Окно, содержащее текст "Hello, Windows desktop!", должно появиться в левом верхнем углу экрана.
Поздравляем! Вы выполнили это пошаговое руководство и создали традиционное классическое приложение Windows.
Здравствуй, хабрасообщество! Не знаю, будет ли этот топик полезен кому-либо, но надеюсь, что вы почерпнете здесь для себя что-то новое. Цель данной статьи — познакомить хабраюзеров с проектом COSMOS и показать, как можно реализовать собственную ОС, заточенную под Ваши нужды. Кому интересно — прошу под кат.
Знакомимся с COSMOS
Что нам потребуется?
Начинаем кодить
Это, так сказать, каркас нашей ОС. Теперь добавим в проект класс CommandPrompt, который будет отвечать за ввод и выполнение команд.
Для корректной работы данного класса нам требуется добавить ссылку на библиотеку Cosmos.Sys.Plugs.dll. Она находится здесь: С:\папка_установки_cosmosUserKit\\Build\VSIP.
Ну что же, осталась самая малость: добавляем в метод Run() класса Kernel вызов метода CommandPrompt.Read():
Вот и все. Мы реализовали простейшие команды ОС, теперь остается только скомпилировать наш проект и запустить его на виртуальной машине.
Для этого жмем Построение->построить решение, сохраняем наш проект и открываем Visual Studio 2010 Shell. Нажимаем создать проект и видим данное окно:
Создаем Cosmos Project, и в References добавляем ссылку на .dll — файл, получившийся в результате построения проекта. Этот длл находится в папке нашего первого проекта\bin\debug. ВАЖНО! Если у вас не установлен VMWarePlayer или Workstation, то открываем свойства проекта и выбираем ISO Image, как показано ниже:
После этого так же нажимаем построить решение, ждем, так как построение выполняется сравнительно долго, и после успешного построения закрываем Visual Studio Shell, не забыв при этом сохранить проект. В итоге в папке второго проекта\bin\debug мы найдем .iso — файл. Его можно записать на диск или на флешку и грузить нашу ОС на реальном железе. Можете запустить в виртуальной машине нашу ОС и полюбоваться результатом :)
Вот и все! Я надеюсь, что вы узнали что-то новое, прочитав эту статью. Постараюсь ответить на все Ваши вопросы в комментариях, если что-то будет непонятно.
Цель статьи — провести начинающего за руку по первому UEFI проекту, оставаясь в привычной ему среде. Для более опытных людей, надеюсь, будет интересным поработать в VS вместо привычной командной строки, или разобрать подход и перенести его в любимый Eclipse.
Начнем с простых вещей, вывода строки на консоль и русификации (довольно востребованная вещь, причем простая в реализации), потом будет работа с формами в HII (то, что называлось в обиходе страницами BIOS Setup), потом графика, потом Boot Manager, а потом видно будет (с).
Желающие — прошу пожаловать под кат.
Сейчас необходимо решить, оно вам надо или нет. Потратим на это пол-страницы на старте, чтобы не тратить пол-дня и в конце понять, что вам надо совсем другое. Или, надеюсь, наоборот — загореться энтузиазмом и выкроить время на прочтение статьи.
Вначале хорошее
1) Аппаратура не понадобится от слова совсем. Никаких Evaluation Boards, никаких Intel BlueBox JTAG за $3000. Все будет отлаживаться в 32-битной виртуальной машине OVMF – портированной Интелом виртуалке qemu для отладки UEFI Firmware. Для перекомпиляции под реальную платформу достаточно потом — после отладки — переставить пару ключей в настройках компиляции, и на этом все.
3) Файловая система виртуалки доступна на Windows-машине для записи-чтения. Очень пригодится, если надо будет редактировать скрипты UEFI Shell, после запуска посмотреть скриншоты и проанализировать логи средствами Windows.
4) Никакого ассемблера, только С/С++.
Теперь о том, что мы делать не будем
1) Мы будем работать в DXE (где уже есть UEFI Shell) и поздних фазах. В более ранние фазы не полезем, поскольку нас туда никто не пустит, по крайней мере – для Intel-процессоров. Позже будет объяснение, почему. Если хотите сделать полный цикл, от включения до загрузки ОС, причем быстро и не забивая голову кучей ненужной и неинтересной вам в данный момент информацией, а ручное конфигурирование системы вам совершенно не требуется – дальше не читайте, а наберите в Гугле «coreboot».
2) «Графического» UEFI с мышкой и кнопками, как у Dell, MSI и прочих, здесь не будет. Это платные среды, для использования в крупных компаниях. Есть, разумеется, энтузиасты, которые сами создают их своими руками, не ответив предварительно на вопрос «Зачем?», но обычно их энтузиазм заканчивается на второй форме с кнопками.
3) Мы будем работать с компилятором Visual Studio. Желающие могут настроить gcc в cygwin, или icc, но в данный момент не стоит задача получить оптимальный быстрый код, а стоит задача быстро пройти путь к началу полноценной работы.
Все, предварительные танцы закончены, кто надо – воодушевлен, кто надо – напуган.
Переходим к делу
Итак, у кого на машине есть git в командной строке, выполняют команду в cmd окне (или в Far Commander, не суть) из корневого каталога:
а те, у кого нет, идут по ссылке на github, скачивают zip-файл и раскрывают его в каталог с:/FW.
Как было ранее обещано, приведем подсказку из Интеловского тренинга по использованию другой конфигурации, отличной от указанной в начале статьи. Ищите свое сочетание в табличке, если предлагаемое по каким-то причинам не подходит:
Конфигурирование среды для версии, отличной от VS2010
Открываем файл c:\FW\edk2\Conf\target.txt и в строчке
TOOL_CHAIN_TAG = VS2010x86
Заменяем VS2010x86 на тэг установленной у вас версии Visual Studio. Для Visual Studio 2010 тэг останется как есть, для других версий VS – смотрите картинку выше, или список в начале файла c:\FW\edk2\Conf\tools_def.txt
Собственно, среда разработки edk2 развернута полностью и в ней можно работать из командной строки. Некоторые так и работают всю жизнь («угорать по хардкору, поддерживать дух старой школы и всё такое» — (с) CodeRush в своей ставшей классической статье). Но мы все же пойдем дальше, пересаживать человека из MSVS обратно в командную строку — негуманно, особенно в 2017.
Настраиваем проект в Visual Studio
Открываем Visual Studio, в нем открываем Solution NT32.sln из каталога C:\FW\VS\NT32. В целях уменьшения времени входа в тему, в solution уже создан одноименный проект NT32, в котором уже сделаны описанные ниже настройки. Это если не получится создать самим – чтобы иметь гарантированно рабочие настройки проекта. Такой подход сильно сократит время поиска источника проблем, в случае их появления. Тем не менее, лучше пройти описанный ниже путь самим, и понять смысл настроек – это облегчит настройку следующих проектов.
Полезно будет сразу в Tools->Options настроить рабочий каталог на c:\FW\VS, но если в VS ведется другой, рабочий проект, то так делать не надо:
Создание проекта
Создаем в Solution NT32 новый проект для Visual C++ (правой клавишей на Solution NT32, Add->New Project, выбираем опцию Makefile Project), и назовем его MyFirstUEFIProject (или как угодно еще). Жмем Finish.
Выбираем в Solution проект NT32, выбираем из контекстного меню Project->Properties и производим настройки проекта.
Настройка NMake опций
Выбираем в окне слева строку Configurarion Properties → NMake, в окне справа — строку Build Command Line
Жмем Edit… и в открывшемся текстовом окне вводим:
Сейчас стоит немного объяснить, что мы делаем. По сути, мы пишем в этом окне обычный пакетный bat-файл вместо makefile.
В первой строке устанавливается переменная окружения ассемблера NASM_PREFIX в том виде, как ее понимает edk2, то есть путь, по которому лежит файл nasm.exe. На ассемблере мы сами писать не будем, но нашей системе сборки ассемблер нужен обязательно.
Во второй строке вызывается скрипт настройки среды edk2 и настраиваются переменные окружения для данного сеанса компиляции и запуска (вне VS эти переменные не отражаются). Ключ –nt32 указывает системе сборки, что компилировать исходники надо для пакета (package) Nt32Pkg, расположенного в C:\FW\edk2\Nt32Pkg. Этих пакетов там много, мы их рассмотрим, но не сейчас.
В третьей строке мы даем команду на компиляцию в только что настроенной среде (build.exe лежит в C:\FW\edk2\BaseTools\Bin\Win32, этот путь прописывается в предыдущей строчке, в edksetup.bat)
Итак, вот что у нас должно появиться в итоге в текстовом окне Build Command Line:
Затем вводим в следующей строке Rebuild Command Line в открывшееся по Edit … окно следующий текст
Команда build clean означает то самое, что вы предполагаете. Она делает полную перестройку проекта с перекомпиляцией всех модулей.
Что мы вводим в окне из Clean Command Line, наверное, все уже догадались:
Честно говоря, особо эта опция не нужна, в 99% случаев хватит Rebuild, но пускай будет – например, очистить среду для ее переноса в другое место или заливки на github.
В итоге, у нас должно получиться вот такое окно:
Все с настройкой NMake.
Настройка опции Debugging
Итак, открываем строчку Debugging и вводим:
В строчке Command:
В строчке “Working Directory”:
SecMain.exe – объяснять сейчас, что это такое – долго, если очень кратко и упрощенно – то это аналог bootloader-a, который запускает все остальное.
Рабочий каталог – сюда будут помещаться все успешно созданные модули, и доступны они будут все сразу из командной строки.
Итак, вот что мы должны получить после настроек в этом окне:
На этом все с настройками проекта.
Построение проекта
========== Build: 1 succeeded, 0 failed, 0 up-to-date, 0 skipped ==========
Если же вместо этого получено что-то иное, смотрите, правильно ли вы прошли все шаги. Наиболее тяжелый случай – получить:
LINK : fatal error LNK1123: failure during conversion to COFF: file invalid or corrupt
это баг среды VS2010 и означает, что VS2010 установлен без SP1. Поставьте SP1, или ищите способы затыкания этой ошибки в инете.
Работа в UEFI Shell
Итак, все скомпилялось хорошо, и вы читаете эти строки. Теперь жмем на любимую F5 и после примерно минуты работы с диском (чуть позже сократим и это время) получаем вот такую требуемую картинку:
Собственно, это и есть UEFI Shell. Как в нем работать – написана куча руководств, посмотрите в Гугле, а мы пока сделаем в нем несколько вещей.
1. Смотрим, что мы там накомпиляли за эти 10 минут. Вводим fs0: (UEFI Shell нечувствителен к регистру) и затем ls –b, где опция –b означает ожидание нажатия Enter для прокрутки страницы, ибо список там большой, не на один экран.
Теперь стало понятно, что означал параметр “Working Directory” в настройке опций проекта Visual Studio — C:\FW\edk2\Build\NT32IA32\DEBUG_VS2010x86\IA32\. Там этот же самый список файлов, и лучше его смотреть (и редактировать скрипты) через развитую оболочку Far Commander (или Total Commander), чем с командной строки в UEFI Shell.
2. В UEFI Shell и набираем “hel”, жмем Tab и видим на экране Helloworld.efi. Не то, чтобы мы совсем не догадывались, что будет, если нажать после этого Enter, но проверить-то надо! Жмем и получаем троекратное UEFI Hello World!. Число повторений – это конфигурируемый в настройках среды (а не в исходниках) внешний параметр и мы будем эту конфигурацию потом разбирать.
3. Набираем exit и попадаем в наше любимое и знакомое окно:
Ну вот, можно любоваться на плоды своих трудов. После этого стрелками гоним фокус на Reset и виртуалка закрывается, возвращая нас в знакомое окно MSVC.
Выводим свою строку
Создание полностью своего приложения потребует достаточно много настроек, которые лучше будет рассмотреть в следующей статье — иначе получится большой объем, а длинные простыни никто не читает. Однако же в заголовке этой статьи написано «Программирование», а мы пока занимались только настройкой. Чтобы сдержать обещание, давайте в этой статье сделаем очень простую модификацию приложения HelloWorld, используя его имеющийся набор файлов, а в следующей статье создадим свой, при помощи Интеловской утилиты UEFI Driver Wizard, поскольку прогонять начинающих по полному циклу создания набора файлов для UEFI драйвера (или приложения) — это нечеловеколюбиво, дико рутинно и несет риск потери 90% аудитории. Если человека зацепит — он сам к этому придет со временем, а если хочется просто поиграться — нет смысла тратить на это кучу времени, благо многое давно уже делается автоматически через UEFI Driver Wizard, причем по фэн-шуй, чего от новичка ждать наивно.
Итак, открываем в Visual Studio файл
C:\FW\edk2\MdeModulePkg\Application\HelloWorld\HelloWorld.c
И добавим свою простую строчку, сразу после объявления переменных в единственной функции:
Разумеется, текст можно заменить на что угодно, только английскими буквами — русский шрифт edk2 еще не понимает, мы добавим его в следующих статьях. Можете поставить на эту строку обычный breakpoint и посмотреть, как себя поведет Visual Studio.
Жмем F5, после компиляции и устранения ошибок вводим «fs0:», HelloWorld.efi и получим такой вывод:
На этом все. В следующей статье мы немного поработаем в UEFI Shell, чтобы освоиться, и разберем немного теории.
Данный цикл статей посвящён низкоуровневому программированию, то есть архитектуре компьютера, устройству операционных систем, программированию на языке ассемблера и смежным областям. Пока что написанием занимаются два хабраюзера — iley и pehat. Для многих старшеклассников, студентов, да и профессиональных программистов эти темы оказываются весьма сложными при обучении. Существует много литературы и курсов, посвящённых низкоуровневому программированию, но по ним сложно составить полную и всеохватывающую картину. Сложно, прочитав одну-две книги по ассемблеру и операционным системам, хотя бы в общих чертах представить, как же на самом деле работает эта сложная система из железа, кремния и множества программ — компьютер.
Каждый решает проблему обучения по-своему. Кто-то читает много литературы, кто-то старается поскорее перейти к практике и разбираться по ходу дела, кто-то пытается объяснять друзьям всё, что сам изучает. А мы решили совместить эти подходы. Итак, в этом курсе статей мы будем шаг за шагом демонстрировать, как пишется простая операционная система. Статьи будут носить обзорный характер, то есть в них не будет исчерпывающих теоретических сведений, однако мы будем всегда стараться предоставить ссылки на хорошие теоретические материалы и ответить на все возникающие вопросы. Чёткого плана у нас нет, так что многие важные решения будут приниматься по ходу дела, с учётом ваших отзывов.
Возможно, мы умышленно будем заводить процесс разработки в тупик, чтобы позволить вам и себе полностью осознать все последствия неверно принятого решения, а также отточить на нем некоторые технические навыки. Так что не стоит воспринимать наши решения как единственно верные и слепо нам верить. Еще раз подчеркнём, что мы ожидаем от читателей активности в обсуждении статей, которая должна сильно влиять на общий процесс разработки и написания последующих статей. В идеале хотелось бы, чтобы со временем некоторые из читателей присоединились к разработке системы.
Мы будем предполагать, что читатель уже знаком с основами языков ассемблер и Си, а также элементарными понятиями архитектуры ЭВМ. То есть, мы не будем объяснять, что такое регистр или, скажем, оперативная память. Если вам не будет хватать знаний, вы всегда можете обратиться к дополнительной литературе. Краткий список литературы и ссылки на сайты с хорошими статьями есть в конце статьи. Также желательно уметь пользоваться Linux, так как все инструкции по компиляции будут приводиться именно для этой системы.
А теперь — ближе к делу. В оставшейся части статьи мы с вами напишем классическую программу «Hello World». Наш хеллоуворлд получится немного специфическим. Он будет запускаться не из какой-либо операционной системы, а напрямую, так сказать «на голом железе». Перед тем, как приступить непосредственно к написанию кода, давайте разберёмся, как же конкретно мы пытаемся это сделать. А для этого надо рассмотреть процесс загрузки компьютера.
Итак, берем свой любимый компьютер и нажимаем самую большую кнопочку на системном блоке. Видим веселую заставку, системный блок радостно пищит спикером и через какое-то время загружается операционная система. Как вы понимаете, операционная система хранится на жёстком диске, и вот тут возникает вопрос: а каким же волшебным образом операционная система загрузилась в ОЗУ и начала выполняться?
- Обнаружить все подключенные устройства (процессор, клавиатуру, монитор, оперативную память, видеокарту, голову, руки, крылья, ноги и хвосты…) и проверить их на работоспособность. Отвечает за это программа POST (Power On Self Test – самотестирование при нажатии ВКЛ). Если жизненно важное железо не обнаружено, то никакой софт помочь не сможет, и на этом месте системный динамик пропищит что-нибудь зловещее и до ОС дело вообще не дойдет. Не будем о печальном, предположим, что у нас есть полностью рабочий компьютер, возрадуемся и перейдем к рассмотрению второй функции BIOS:
- Предоставление операционной системе базового набора функций для работы с железом. Например, через функции BIOS можно вывести текст на экране или считать данные с клавиатуры. Потому она и называется базовой системой ввода-вывода. Обычно операционная система получает доступ к этим функциям посредством прерываний.
- Запуск загрузчика операционной системы. При этом, как правило, считывается загрузочный сектор — первый сектор носителя информации (дискета, жесткий диск, компакт-диск, флэшка). Порядок опроса носителей можно задать в BIOS SETUP. В загрузочном секторе содержится программа, иногда называемая первичным загрузчиком. Грубо говоря, задача загрузчика — начать запуск операционной системы. Процесс загрузки операционной системы может быть весьма специфичен и сильно зависит от её особенностей. Поэтому первичный загрузчик пишется непосредственно разработчиками ОС и при установке записывается в загрузочный сектор. В момент запуска загрузчика процессор находится в реальном режиме.
На картинке изображена поверхность дискового накопителя. У дискеты 2 поверхности. На каждой поверхности есть кольцеобразные дорожки (треки). Каждый трек делится на маленькие дугообразные кусочки, называемые секторами. Так вот, исторически сложилось, что сектор дискеты имеет размер 512 байт. Самый первый сектор на диске, загрузочный сектор, читается BIOS'ом в нулевой сегмент памяти по смещению 0x7С00, и дальше по этому адресу передается управление. Начальный загрузчик обычно загружает в память не саму ОС, а другую программу-загрузчик, хранящуюся на диске, но по каким-то причинам (скорее всего, эта причина — размер) не влезающую в один сектор. А поскольку пока что роль нашей ОС выполняет банальный хеллоуворлд, наша главная цель — заставить компьютер поверить в существование нашей ОС, пусть даже и на одном секторе, и запустить её.
Как устроен загрузочный сектор? На PC единственное требование к загрузочному сектору — это содержание в двух его последних байтах значений 0x55 и 0xAA — сигнатуры загрузочного сектора. Итак, уже более-менее понятно, что нам нужно делать. Давайте же писать код! Приведённый код написан для ассемблера yasm.
Эта короткая программа требует ряда важных пояснений. Строка org 0x7C00 нужна для того, чтобы ассемблер (имеется в виду программа, а не язык) правильно рассчитал адреса для меток и переменных ( puts_loop, puts_loop_exit, message ). Вот мы ему и сообщаем, что программа будет загружена в память по адресу 0x7C00.
В строках
происходит установка сегмента данных ( ds ) равным сегменту кода ( cs ), поскольку в нашей программе и данные, и код хранятся в одном сегменте.
В строке « jmp $ » программа зависает. И правильно, незачем ей выполнять лишний код. Однако чтобы компьютер опять заработал, придется перезагрузиться.
В строке « times 0x1FE-finish+start db 0 » производится заполнение остатка кода программы (за исключением последних двух байт) нулями. Делается это для того, чтобы после компиляции в последних двух байтах программы оказалась сигнатура загрузочного сектора.
С кодом программы вроде разобрались, давайте теперь попробуем скомпилировать это счастье. Для компиляции нам понадобится, собственно говоря, ассемблер — выше упомянутый yasm. Он есть в большинстве репозиториев Linux. Программу можно откомпилировать следующим образом:
Полученный файл hello.bin нужно записать в зарузочный сектор дискеты. Делается это примерно так (разумеется, вместо fd нужно подставить имя своего дисковода).
Поскольку далеко не у всех остались дисководы и дискеты, можно воспользоваться виртуальной машиной, например, qemu или VirtualBox. Для этого придётся сделать образ дискеты с нашим загрузчиком и вставить его в «виртуальный дисковод».
Создаём образ диска и заполняем его нулями:
Записываем в самое начало образа нашу программу:
Запускаем полученный образ в qemu:
После запуска вы должны увидеть окошко qemu с радостной строчкой «Hello World!». На этом первая статья заканчивается. Будем рады увидеть ваши отзывы и пожелания.
Проекты Linux можно создавать в Visual Studio версии 2017 и выше.
Сначала убедитесь, что вы установили рабочую нагрузку разработки для Linux в Visual Studio. См. дополнительные сведения о скачивании, установке и настройке рабочей нагрузки для Linux.
Для кросс-платформенной компиляции рекомендуем использовать CMake. Более комплексная поддержка CMake предоставляется в Visual Studio 2019. Если CMake вам не подходит и у вас есть решение Windows в Visual Studio, в котором нужно обеспечить возможность компиляции для Linux, добавьте проект Visual Studio для Linux в решение Windows вместе с проектом общих элементов. Поместите код, совместно используемый обеими платформами, в проект общих элементов и добавьте ссылку на него из проектов Windows и Linux.
Создание проекта Linux
Чтобы создать проект Linux в Visual Studio 2017, сделайте следующее:
Выберите Файл > Создать проект в Visual Studio или нажмите клавишиCTRL+SHIFT+N.
Выберите узел Visual C++ > Кроссплатформенный > Linux, а затем укажите тип проекта, который хотите создать. Укажите имя и расположение, а затем щелкните ОК.
Сначала убедитесь, что вы установили рабочую нагрузку разработки для Linux в Visual Studio. Ознакомьтесь с дополнительными сведениями о скачивании, установке и настройке рабочей нагрузки для Linux.
При создании в Visual Studio нового проекта C++ для Linux можно выбрать его тип: Visual Studio или CMake. В этой статье описано, как создать проект Visual Studio. В большинстве случаев для новых проектов, которые могут содержать открытый код или которые нужно компилировать для кроссплатформенной разработки, рекомендуется использовать CMake с Visual Studio. С помощью проекта CMake вы можете выполнять сборку и отладку одного и того же проекта и в Windows, и в Linux. Дополнительные сведения см. в статье Создание и настройка проекта Linux CMake.
Если у вас есть решение Windows в Visual Studio, в котором нужно обеспечить возможность компиляции для Linux, и CMake вам не подходит, добавьте проект Visual Studio для Linux в решение Windows вместе с проектом общих элементов. Поместите код, совместно используемый обеими платформами, в проект общих элементов и добавьте ссылку на него из проектов Windows и Linux.
Создание проекта Linux
Чтобы создать проект Linux в Visual Studio, сделайте следующее:
Выберите Файл > Создать проект в Visual Studio или нажмите клавишиCTRL+SHIFT+N. Появится диалоговое окно "Создание проекта".
В текстовом поле Поиск шаблонов введите Linux, чтобы получить список доступных шаблонов для проектов Linux.
Выберите тип создаваемого проекта, например Консольное приложение, а затем нажмите кнопку Далее. Укажите имя и расположение, а затем щелкните Создать.
Читайте также: