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

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

 

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

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

 

Из чего состоит ОС телефона

Операционная система телефона, как и любая другая, состоит их двух основных компонентов:

1. Ядро — это «сердечная мышца» любой ОС, которая всегда запускается первой при включении устройства. Именно ядро манипулирует системными ресурсами телефона.

2. Системный софт — это программы, которые работают «над ядром». Они очень важны для самого ядра, потому что обеспечивают эффективную связь между ядром и приложениями пользователя. В такой софт входят драйвер, файловая система, программы для работы с сетью, системные утилиты и др.

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

• браузер;

• аудиоплеер;

• блокнот;

• книга контактов;

• мессенджеры;

• и др.

Именно такие программы находятся под контролем ядра, которое выделяет на их запуск необходимое количество ресурсов системы.

 

Что необходимо знать, чтобы создать свою операционную систему для телефона 

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

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

1. Основы информатики. Сюда входит понимание таких вещей, как: алгоритмы, структуры данных, сортировка, манипулирование данными, абстрактное программирование и мн. др.

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

3. Язык программирования. Большинство операционных систем используют язык программирования С или С++, поэтому знать эти языки нужно будет в любом случае. Даже если решите создавать свою ОС на другом языке,  примеры в документации и большинство готовых фрагментов кода будут именно на этом языке.

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

5. Опыт в программировании. Если создание своей операционной системы для телефона — это первый ваш проект, то это довольно плохая идея. Вам кроме самого языка программирования нужно еще понимать как осуществляется контроль версий, отладка, оптимизация кода и мн. др.

6. Много практики на языке, который хотите применять для создания своей операционной системы. Язык не должен быть для вас чем-то новым. Необходимо знать его тонкости и особенности, поэтому на этом языке у вас должно быть реализовано несколько успешных проектов.

7. Понимание UNIX. Начав работу над своей операционной системой для телефона, вы очень быстро осознаете, что основной инструмент создания ОС тянется еще с UNIX-систем, а за основу ОС очень часто берется ядро Linux.

8. Концепция операционных систем. Вы должны в общем понимать, как с технической стороны работают операционные системы на телефонах.

9. И др.

 

Разработка операционной системы для телефона

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

Тут важно понимать, что над действительно стоящей операционной системой для телефонов трудятся десятки программистов даже в таких компаниях как Google или Apple, при этом  на эту сферу у них рассчитаны огромные бюджеты.  Но ни труд десятков программистов, ни огромные деньги не спасают их ОС от багов, которые то и дело всплывают. 

Поэтому тут важно задуматься, а действительно ли вы сможете самостоятельно создать стоящую ОС? И действительно ли она будет лучше существующих, чтобы создать им конкуренцию? Если да, и вы действительно планируете создать программный продукт, который будет конкурировать с Android или iOS, тогда вам лучше обзавестись хорошей командой. Duolingo apžvalga ir įvertinimas Для этого можно выложить свой проект на GitHub и совместными усилиями «пилить» вашу операционную систему.

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

Литература, которая вам пригодится:

1. «Linux From Scratch». Это полноценный учебник по сборке операционных систем Linux. Да, там описываются компьютерные операционные системы, но с технической стороны и мобильная, и компьютерная ОС работают практически одинаково.

2. «The little book about OS development». Еще одна книга о разработке операционных систем для компьютера с самого начала — с установки IDE и до самого конца — до запуска ОС.

 

Заключение

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

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

Создание прошивки для Android

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

Читайте также: Как восстановить прошивку на Android

Шаг 1: Установка Recovery

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

Подробнее: Как установить рекавери на Android

Шаг 2: Выбор прошивки

Помимо добавления загрузчика с возможностью сохранения доступа к файлам нужно найти прошивку, совместимую с вашим девайсом. В этом вопросе трудно дать какие-то конкретные советы, так как существует огромное количество смартфонов и не менее большой ассортимент прошивок. Проще всего найти подходящий вариант, посетив раздел «Android» на русскоязычном форуме 4PDA или на англоязычном ресурсе XDA Developers.

Перейти к прошивкам на 4PDA
Перейти на форум XDA Developers

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

Шаг 3: Подготовка системы на ПК

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

1. Посетите официальный сайт Oracle и загрузите программное обеспечение JDK в соответствии с разрядностью вашей операционной системы.

   Перейти к скачиванию JDK

   Кликните по загруженному EXE-файлу и произведите инсталляцию программы.





2. Следом за JDK нужно скачать и установить Cygwin. Для этого посетите тему на форуме 4PDA по представленной ниже ссылке.

   Перейти к скачиванию Cygwin

3. Откройте загруженный архив при помощи любого удобного архиватора и извлеките имеющиеся файлы.



4. Среди полученных файлов дважды кликните по «Setup», чтобы начать установку.



5. На этапе «Choose A Download Source» выберите вариант «Install from Local Directory» и нажмите «Далее».



6. В строке «Root Directory» путь оставьте без изменений, воспользовавшись кнопкой «Далее».



7. Дальше нужно изменить «Local Package Directory», указав папку Cygwin, которую вы извлекли из архива ранее. К примеру, в нашей ситуации она находится на рабочем столе, и потому путь выглядит так, как показано на скриншоте.



8. Последним шагом является выбор компонентов в окне «Select Packages», которое появится практически сразу после начала установки. Кликните по строке «All», чтобы рядом с каждым пунктом появилась подпись «Install».
   

   Дальнейшие действия по установке Cygwin производятся в автоматическом режиме.

   

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



9. Запустите программу с помощью созданного значка. В ОС Windows выше семерки используйте «Запуск от имени администратора».
   

   Дождитесь завершения создания директорий и файлов в консоли, после чего закройте Cygwin.

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

Шаг 4: Использование Android Kitchen

Программа Android Kitchen, так же известная как «кухня», представляет собой наиболее удобное средство для создания кастомных прошивок. Загрузить архив можно с официальной страницы на Github по ниже представленной ссылке. Лучше всего брать последнюю вышедшую версию ПО.

Перейти к скачиванию Android Kitchen

1. Загрузив «кухню» на компьютер, извлеките папку из архива так же, как и на прошлом этапе.



2. Переименуйте папку в «kitchen» и с помощью комбинации клавиш «CTRL+X» подготовьте к переносу.



3. Откройте «Локальный диск (C:)» и откройте папку по следующему пути: Cygwin/home/user. Нажмите сочетание клавиш «CTRL+V», чтобы добавить ранее извлеченную папку.
   

   Примечание: Вместо «user» папка будет названа в соответствии с именем пользовательской директории в системе.



4. Переместите заранее скачанный файл прошивки, подходящей для вашего устройства, в папку «original_update». Эта директория расположена по следующему пути: Cygwin/home/user/kitchen/original_update.



5. Вновь запустите Cygwin и последовательно воспользуйтесь следующими командами:

   cd kitchen
./menu

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

Закройте «кухню» и переходите к следующему этапу.

Шаг 5: Сборка прошивки

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

1. В главном меню Android Kitchen введите «0» и нажмите «Enter», чтобы перейти к расширенному списку параметров.
   

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

2. Для завершения нужно будет ввести «99» и нажать «Enter». Готовый файл будет находиться в папке «OUTPUT_ZIP» в пользовательской директории Cygwin.

Завершив процедуру редактирования, можно приступать к прошивке устройства.

Шаг 6: Установка прошивки

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

Подробнее:
Как установить кастомную прошивку на Android
Инструкции по перепрошивке смартфонов

Заключение

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

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

Разберем частный случай и начнем по порядку. Для создания кастомной прошивки андроид потребуются:

1. Персональный или переносной компьютер, на борту которой присутствует операционная система Ubuntu и установлена Java.
2. «Кухня» — приложение для обработки образов системных партиций.
3. Собственно сама, подлежащая обработке прошивка Android.

 Шаг 1 — установка Ubuntu

Система Ubuntu создана на базе ядра Linux и основывается на Debian, разработана компанией Canonical. Эту систему вовсе не обязательно устанавливать вместо действующей, запускать ее через эмулятор, и так далее.

Чтобы комфортно использовать все ее преимущества, достаточно воспользоваться приложением Wubi, способным установить Ubuntu под Windows. Wubi — сокраoение от Windows Ubuntu Installer.

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

Шаг 2 — установка Java

Java – разработанный в 1995 году язык программирования, его название, по всей видимости, взято из кинофильмов (смешной народец Джава из Звездных Войн).

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

Чтобы установить ее нужно:

1. Войти в систему Ubuntu, и открыть Терминал при помощи клавиш Ctrl+Alt+T.
2. В открывшемся окне для ввода/вывода информации в ОС Ubuntu воспользоваться командой sudo add-apt-repository “deb http://archive.canonical.com/ubuntu lucid partner” — позволяет подключить новый репозиторий, с которого можно загрузить Java. Для этого потребуется ввести пароль для получения прав Суперадминистратора, который задается при установке Ubuntu. Далее нужно воспользоваться следующими командами:
3. sudo apt-get update для обновления списка источников.
4. sudo apt-get install sun-java6-jre sun java6-plugin sun-java6-fonts для установки Java.

Шаг 3 — работа с «кухней» для создания прошивки

Программа «кухни» — это основное средство для работы с прошивками андроид. Их существует несколько видов, мы рассмотрим работу с kitchen от Dsixda.

• Скачав необходимые файлы, нужно распаковать их в домашнюю папку в каталог kitchen.
• Запустить Терминал, при помощи команды Is вывести на его экран список документов домашней папки. Синим цветом будут выделены каталоги, красным — файлы архивов, и так далее.
• Открыть в проводнике папку Kitchen, перенести в каталог original_update файл обрабатываемой прошивки в любом формате.
• Возвратиться в Терминал с открытой папкой Kitchen, ввести команду Is. Среди файлов появится Menu, его следует запустить командой ./menu. Здесь откроется список пронумерованных команд, которые можно выполнять, вводя их номер в строку, и нажимая Enter.
• Чтобы разобрать прошивку, следует ввести команду 1. Кухня после этого начнет выводить множество вопросов, на которые нужно отвечать клавишей Enter (нужные значения введены по умолчанию).

Эти действия приведут в начальное меню программы. Вернувшись в папку Kitchen, можно будет найти папку «WORKING_x_y», где x и y – дата и время ее создания.

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

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

Для этого нужно вернуться в Терминал, ввести команду 99, снова ответить клавишей Enter на все возникающие вопросы. После этого программа выбросит пользователя в начальное меню, а в папке OUTPUT_ZIP будет лежать файл новой прошивки, которую затем можно устанавливать на мобильное устройство.

Есть и другие способы создания авторских кастомных прошивок android, а необходимые для этого программы можно найти в сети, они позволяют «вскрыть» файлы операционной системы, и изменять те или иные параметры по своему желанию.

Вот еще несколько программ, предназначенных для этого:

• Android SDK – среда разработки, созданная специально для работы с приложениями для Android, она позволяет проверять программный код.
• Android Kitchen – необходима для обработки образов системных партиций в прошивке.
• JD-GUI – декомпилятор, способный к работе с программным языком Java. Его аналог – DJ Java Decompiler.
• smali – для работы с dalvik-кодом. Предназначена для дизассемблирования кода, backsmali позволяет произвести ассемблирование dalvik-кода.
• dex2jar – утилита, позволяющая конвертировать исполняемые файлы, составленные на dalvik-коде.

Одна из ключевых особенностей Android – это открытый исходный код. Исходный код всей операционной системы, включая ядро, пользовательский интерфейс, библиотеки и ключевые приложения, доступен бесплатно. Это означает, что любой (обладающий необходимыми техническими навыками) может собрать Android из исходных кодов и перенести его на совместимое устройство. Эта гибкость позволила различным группам, как коммерческим, так и любителям, разработать альтернативные дистрибутивы Android. Их обычно называют «кастомные прошивки», но лучше называть их «кастомные прошивки».

Поскольку все необходимые строительные блоки доступны, возможно, вы задавались вопросом, насколько сложно создать свой собственный ПЗУ, собственную персонализированную версию Android! Это действительно возможно, читайте дальше, чтобы узнать больше.

Предупреждение

Прежде чем мы погрузимся в темный мир создания пользовательских версий Android, нам нужно сделать паузу и оценить масштабность предстоящей задачи, сдерживая свои ожидания. Если у вас нет абсолютно никакого опыта программирования, нулевого опыта использования командной строки (в Linux или macOS) или вы не знаете, что такое «Makefile», то это не для вас.

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

Было сказано, что. Если вы знакомы с написанием кода, если вы немного знаете о Make-файлах и компиляторах, то создание собственной версии Android может быть полезным опытом!

Предпосылки

Теоретически можно было бы создать специальную прошивку Android для любого вычислительного устройства, способного работать с современной операционной системой. Однако, чтобы облегчить жизнь, мы ограничимся сборкой Android для устройств, которые поддерживают «из коробки», а именно для устройств Nexus. Для демонстрационной сборки я использовал Nexus 5X.

Чтобы собрать Android, вам понадобится доступ (и знакомство) с Linux-машиной или Mac. В обоих случаях вы будете часто использовать терминал, и вам нужно быть уверенным в командах оболочки. Я сделал свою первую сборку с использованием виртуальной машины Linux, однако она не распознала Nexus 5X в режиме загрузчика, поэтому мне не удалось прошить новую прошивку на устройстве. Затем я переключился на Mac, и он работал без особых проблем.

Вам понадобится 130 ГБ дискового пространства и, вероятно, около 8 ГБ ОЗУ. Я попытался собрать Android всего с 4 ГБ оперативной памяти и столкнулся с множеством проблем. Я также столкнулся с аналогичными проблемами с 8 ГБ оперативной памяти, однако, используя некоторые уловки (см. Ниже), я смог создать успешную сборку.

Научитесь терпению. Создать Android не так быстро. На синхронизацию исходного репозитория с моей локальной машиной ушло почти 24 часа! Кроме того, полная чистая сборка займет несколько часов. Даже после внесения незначительных изменений вам может потребоваться подождать от 10 до 20 минут для сборки. Все зависит от вашего оборудования, однако не ожидайте, что ваша новая версия Android будет запущена всего за несколько минут.

Версия Android для проекта с открытым исходным кодом Android не включает никаких сервисов Google. Так что таких вещей, как Google Play, YouTube, Gmail и Chrome, не будет. Есть способы прошить эти «гаппсы» на вашу собственную прошивку, но я оставлю вас, чтобы узнать, как это сделать. Подсказка: выполните поиск по запросу «установить gapps».

Когда начать

Основной процесс таков. Загрузите и соберите Android из Android Open Source Project, затем измените исходный код, чтобы получить свою собственную версию. Просто!

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

Я не буду дословно повторять здесь инструкции по сборке, однако общие шаги следующие:

• Настройте среду сборки, включая установку правильных инструментов разработки, Java Development Kit и настройку всех путей и каталогов.
• Возьмите исходный код – это делается с помощью инструмента «Репо» и git.
• Получите проприетарные двоичные файлы – некоторые драйверы выпускаются только в двоичной форме.
• Выберите цель – с помощью инструмента «обед».
• Начните сборку – с помощью make и Джека.
• Прошить сборку на свое устройство – с помощью adb и fastboot.

Советы и рекомендации по процессу сборки

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

Настройте среду сборки – Ubuntu 14.04 является рекомендуемой средой сборки для пользователей Linux и OS X 10.11 для пользователей Mac. Вам необходимо установить OpenJDK 8 в Linux и Oracles JDK 8 в OS X. В OS X вам также необходимо установить Macports вместе с Xcode и инструментами командной строки Xcode. Я использовал OS X 10.12, что вызвало небольшую проблему с устаревшими функциями системных вызовов в 10.12 OS X SDK. Работа здесь: http://palanceli.com/2016/09/25/2016/0925AOSPOnMac/

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

Получите проприетарные двоичные файлы – двоичные драйверы должны быть распакованы в вашем рабочем каталоге.

Выберите цель – для Nexus 5X используйте aosp_bullhead-user

Начать сборку – вы запускаете сборку с помощью make. GNU make может обрабатывать параллельные задачи с аргументом -jN, и обычно используется количество задач N, которое в 1-2 раза превышает количество аппаратных потоков на компьютере, используемом для сборки. Однако, если вы обнаружите, что ваша машина испытывает трудности в процессе сборки, попробуйте что-нибудь вроде «make -j2».

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

• export ANDROID_JACK_VM_ARGS=”-Xmx4g -Dfile.encoding=UTF-8 -XX:+TieredCompilation”change the jack.server.max-service in $HOME/.jack-server/config.properties to 1

Если вы измените какую-либо конфигурацию сервера Джека (включая установку или изменение переменной ANDROID_JACK_VM_ARGS), вам нужно убить сервер Джека и снова запустить make. Используйте ./prebuilts/sdk/tools/jack-admin kill-server, чтобы остановить сервер Джека.

Если у вас возникнут какие-либо ошибки связи, связанные с сервером Jack, просто запустите сборку снова, это обычно исправляет.

Запишите сборку на свое устройство – вы найдете adb и fastboot в ./out/host/darwin-x86/bin/ или ./out/host/darwin-x86/bin/ для OS X или Linux соответственно.

Прошить это

После того, как у вас будет успешная сборка и вы загрузите ее на свое устройство с помощью команды «fastboot flashall -w», перезагрузите устройство. Вы увидите ванильную версию AOSP. Нет сервисов Google, нет Play Store и только несколько основных приложений. Это основа Android.

Тем не менее, наши поздравления не заставят себя ждать. Вам удалось собрать Android из исходного кода и установить его на устройство. Это немалый подвиг.

настройка

Теперь, когда у вас есть Android, вы можете приступить к его настройке и созданию собственного специализированного ПЗУ. На самом деле здесь все усложняется. Вы собираетесь повозиться с операционной системой Android, и проблема в том, что Android огромен. В моем рабочем каталоге более 120 ГБ данных. Это исходный код, графика, скомпилированные двоичные файлы, инструменты, все. Это много всего.

Итак, начнем с простого. Вот две простые настройки, которые помогут вам начать путь к тому, чтобы стать хакером прошивки Android!

Настройте приложение для обмена сообщениями

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

Основные приложения находятся в каталоге ./packages/apps/,  и нас интересует приложение обмена сообщениями в ./packages/apps/Messaging/. Просмотрите src / com / android / messaging / и отредактируйте BugleApplication.java. Вы можете редактировать его с помощью вашего любимого редактора графического интерфейса или, если вы хотите остаться в командной строке, используйте vi или nano .

BugleApplication.java – это точка входа для приложения обмена сообщениями. Для простоты мы собираемся добавить тост, который будет отображаться при первом запуске приложения. В верхней части файла под длинным списком операторов импорта добавьте эту строку:

import android.widget.Toast;

Теперь найдите функцию onCreate(). Ближе к концу функции, перед последним вызовом Trace.endSection (); добавьте следующие две строки:

Toast myToast = Toast.makeText(getApplicationContext(), "Welcome!", Toast.LENGTH_LONG);
myToast.show();

Сохраните файл и запустите новую сборку с помощью команды make. Как только сборка будет завершена, запишите ее на свое устройство и перезагрузите. Запустите приложение обмена сообщениями и найдите «Добро пожаловать!» тост. Очевидно, что это простая модификация, однако есть возможность изменить любое из приложений по умолчанию, как вам угодно.

Больше настроек

Любой уважающий себя кастомный дистрибутив Android должен включать некоторую информацию о самом ПЗУ. Для этого мы можем изменить встроенное приложение «Настройки» и добавить некоторую информацию в раздел «О телефоне». Для этого отредактируйте файл device_info_settings.xml из ./packages/apps/Settings/res/xml/ и добавьте следующие два раздела в конец файла перед последним тегом :

<!-- ROM name -->
<Preference android:key="rom_name"
android:enabled="false"
android:shouldDisableView="false"
android:title="ROM name"
android:summary="Whizz Bang Pop ROM"/>

<!-- ROM build version -->
<Preference android:key="rom_number"
android:enabled="false"
android:shouldDisableView="false"
android:title="ROM build number"
android:summary="7.0.1"/>

Сохраните файл, а затем восстановите и перепрограммируйте прошивку на вашем устройстве. После перезагрузки перейдите в Настройки-> О телефоне и прокрутите вниз:

Вышеупомянутое изменение – это небольшая хитрость, поскольку на самом деле строки должны быть определены в strings.xml для английского и других языков. Если вы планируете серьезно заниматься разработкой AOSP, вам нужно делать все правильно!

Заворачивать

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

Источник записи: https://www.androidauthority.com

Илья Александров

Создаём собственную ОС на базе Linux

Дистрибутивов Linux существует сотни, и неизвестно, сколько появится еще. Десятки компаний и тысячи программистов соревнуются в создании лучшего Linux-проекта, а между тем любой опытный пользователь может стать автором системы для домашнего ПК, не уступающей продуктам гигантов IT-индустрии.

За долгие годы работы с Linux мною было использовано огромное количество различных дистрибутивов: Mandriva, Fedora, SlackWare, Debian, Ubuntu и многие другие. Какой-то проект нравился больше, какой-то – меньше. Но во всех дистрибутивах неминуемо приходилось сталкиваться с серьезными недостатками, которые сильно затрудняли работу. Один слишком требователен к ресурсам, в другом нет поддержки всего нужного оборудования, в третьем не хватает различного ПО. Вот тогда я вспомнил известную восточную мудрость: если нужно что-то сделать хорошо, сделай это сам.

Linux from Scratch

Я не единственный, кто решил заняться построением собственной версии Linux – ОС, в которой за основу будет взята базовая часть системы и ядро, но где не будет ни единого лишнего килобайта от разработчика, то есть от вас. Большое количество Linux-дистрибутивов, не соответствующих требованиям пользователей, подтолкнуло Герарда Бикменса (Gerard Beekmans) к созданию дистрибутива, который даст возможность каждому собрать систему, где будут только необходимые ему компоненты и функции.

Стремление талантливого программиста вылилось в проект Linux from Scratch (www.linuxfromscratch.org), сокращенно – LFS. Этот проект, позволяет сконструировать «с нуля», из исходных кодов, свою операционною систему на базе Linux. Компиляция LFS проходит на компьютере с уже установленной Linux-системой, впрочем, подойдет и «продвинутый» Live-CD, например, Knoppix .

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

Как известно, Линус Торвальдс разрабатывал свою операционную систему под девизом «Just for fun!» – то есть только ради удовольствия. Нужно признать, что LFS действительно не часто можно встретить на серверах, используют эту систему, как правило, компьютерные энтузиасты. Установка и работа с Linux from Scratch поможет вам разобраться во взаимосвязи компонентов ОС, что пригодится при собственных разработках Linux-дистрибутива, причем не только на базе LFS. Поэтому LFS во многом рассчитан на тех людей, для которых процесс сборки собственного дистрибутива увлекателен и интересен – а таких людей, поверьте, немало.

Итак, если вы готовы потратить на конструирование системы целый день (а то и больше), то рекомендую скачать с сайта (2) LFS-packages-6.0, LFS-book, и продолжить читать эту статью.

Разбиение диска и создание дерева каталогов

Для лучшего понимания материала опишем весь ход процесса в общих чертах (см. рис. 1).

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

На протяжении всего процесса ваш главный помощник – документация из пакета LFS-book, русский перевод которой можно взять тут: http://multilinux.sakh.com/download/lfsbook.tar.bz2 . В книге подробно описан каждый шаг создания ОС, поэтому обязательно обращайтесь к этому руководству в случае возникновения проблем (данная статья не призвана заменить такую обширную документацию).

Создаем новый раздел – в моем случае это /dev/hda5, так как раздел /dev/hda1 уже занят установленным на жесткий диск Linux Slackware. Рекомендуется предварительно сделать бэкап системы, дабы можно было ее восстановить в случае повреждения, хотя вероятность подобного близка к нулю. И тут, думаю, все понятно: выделяем нужное количество (достаточно 23 Гб) под корневой каталог, пространство, равное удвоенному объему ОЗУ – под swap-раздел, по желанию можно создать отдельные разделы для домашнего каталога (/home) и для /boot. Впрочем, излюбленный многими вариант разбиения – отвести под корневой каталог все доступное пространство минус swap, и последующее создание собственно swap – также вполне допустимо при сборке LFS. На компьютере автора и Linux Slackware, являющийся родительской ОС, и LFS, используют один жесткий диск, впрочем, установить LFS на другой винчестер тоже труда не составит.

Файловую систему выбирайте на ваше усмотрение: и с Ext3, и с ReiserFS никаких проблем под LFS не было. А вот поклонников XFS придется огорчить – попытки заставить Linux From Scratch работать с этой ФС не увенчались успехом.

Теперь монтируем раздел, отведенный под новую ОС:

$ mount /dev/hda5 /mnt/mylin

Для удобства определим переменную MYLIN:

$ export MYLIN=/mnt/mylin

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

$ useradd mylin

$ chown –R mylin $MYLIN

Нужно создать дерево каталогов в корне нового раздела:

$ cd $MYLIN

$ mkdir –p bin boot dev etc home lib mnt opt root sbin usr/{X11R6,local} var

В каталогах usr, usr/X11R6, usr/local
создаем необходимую структуру:
подкаталоги bin, etc, include, lib, sbin, share, src.

Затем то же самое проделаем для каталогов /var и /opt будущей системы:

$ mkdir var/{cache,lib,local,lock,log,opt,run,spool}

$ mkdir opt/{bin,doc,include,info,lib,man}

Не будем забывать, что существуют более глубокие иерархии, например, /usr/share/man/man1. Но объем статьи не позволяет привести здесь всю информацию о структуре файлового дерева, поэтому нужно либо воспользоваться документом Filesystem Hierarhy Standart (можно найти по адресу: http://linux-ve.net/MyLDP/file-sys/fhs-2.2-rus), либо внимательно изучить структуру уже установленной у вас ОС семейства Linux. После подготовки жесткого диска приступаем к статической сборке.

Статическая сборка

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

Но когда мы посредством команды chroot установим корневой каталог для вновь собираемой системы, библиотеки «родительской», установленной системы, находящиеся в /lib, /usr/lib, и прочих, станут уже недоступны, поэтому динамически скомпилированные программы работать откажутся, вдобавок совместимость версий никем не гарантирована.

Чтобы избежать этого, все необходимое программное обеспечение для нашей будущей системы мы для начала соберем статически. Начнем, пожалуй, с командного интерпретатора bash. (Поклонники ZSH или TCSH могут установить любимые интерпретаторы после установки системы, но на этапе сборки их использование не предусмотрено автором LFS). Следует проверить, есть ли у вас файл /usr/lib/libcurses.a и если его нет – установите пакет nсursesdev. Все пакеты надо собирать с флагами статической сборки: «—enable-static-link», «—disable-shared» или «—static». Какой именно подходит в каждом конкретном случае, можно узнать из документации к конкретному пакету или из вывода конфигурационного сценария, запущенного с параметром «—help».

$ ./configure –-help

Чтобы не спутать позже статически скомпилированные программы с «динамическими», создадим для них специальный каталог:

$ mkdir $MYLIN/stat

При сборке и установке пакетов не забываем добавлять параметр «—prefix=$MYLIN/stat» для перемещения файлов именно в этот каталог. И,
наконец,
ставим bash:

$ ./configure –-enable-static-link —prefix=$MYLIN/stat

$ make

$ make install

По такой же схеме собираем остальные необходимые пакеты: binutils, bzip2, textutils, texinfo, tar, sh-utils, gcc, grep, gzip, gawk, diffutils, fileutils, make, patch, sed,
и,
собственно, linux-kernel.

Да, при компиляции ядра не забываем, что для старых версий ядер (2.2.x-2.4.x) нужно использовать gcc 2.95, а для текущей версии 2.6.x рекомендуется применить gcc 3.x, дабы не возникло проблем.

Не забываем заглядывать в соответствующие разделы LFS-book, там сказано об этом и многих других нюансах. В целом же компиляция ядра в LFS не отличается от подобной процедуры, проводимой при использовании установленного на HDD дистрибутива. Разархивируем исходники ядра в $MYLIN/usr/src/linux-2.6.xx, после чего конфигурируем, запуская:

$ make menuconfig

Процесс настройки параметров ядра многократно описан в Интернете (6), вряд ли есть необходимость останавливаться на этом подробнее. Далее даем следующие команды в папке с исходными текстами Linux-kernel:

$ make bzImage

$ make modules

Все, по адресу $MYLIN/usr/src/linux-2.6.xx/arch/i386/boot/bzImage находится новое ядро.

Далее создаем файлы $MYLIN/etc/passwd и $MYLIN/etc/group. В первом прописываем пока единственного пользователя – root с любым паролем, а во втором группы пользователей (для начала одной группы root тоже будет достаточно).

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

Динамическая сборка

Теперь нам нужно сменить корневой каталог на /mnt/mylin, где мы будем пользоваться только статически собранными утилитами – к помощи инструментов из «родительской» ОС мы уже прибегать не сможем. Даем команду в консоли:

$ chroot $MYLIN/usr/bin/env –i

>HOME=/root TERM=$TERM PS1=’u:w$’

>PATH=/bin: /usr/bin: /sbin: /usr/sbin: /stat/sbin

>/stat/bin/bash —login

Этой командой мы указали пути к исполняемым файлам, тип терминала, интерпретатор и вид приглашения командной строки.

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

$
mount
proc
/proc -t proc

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

При сборке мы указывали параметр «—prefix=$MYLIN/stat», поэтому при смене корня все статически собранные пакеты окажутся в каталоге /stat раздела новой ОС.

Итак, распаковываем архив glibc-2.x.x.tar.gz (например, в директорию /usr/src/) и переходим в каталог glibclinuxthreads. Придется немного подправить исходный код ввиду того, что на данном этапе в системе невозможна идентификация пользователя по имени (как раз из-за отсутствия glibc и других библиотек), и того, что для установки glibc нужен интерпретатор Perl, которого у нас нет.

Заменяем имя пользователя root в файле login/Makefile на его uid, то есть 0, а переменную $PERL в файле malloc/Makefile следует заменить на путь к интерпретатору – /usr/bin/perl – и при конфигурировании он просто будет проигнорирован.

$ /usr/src/glibc-2.x.x/configure —prefix=/usr —enable-add-ons —libexecdir=/usr/bin &&

& make

& make install

$ make localedata/install-locales

$ /stat/bash —login

Если вы все сделали правильно, glibc скомпилируется, в строке приглашения наконец-то появится «root», и можно будет динамически перекомпилировать все программы.

Завершим установку ядра:

$ make modules_install

$ make install

Чтобы переместить новое ядро в каталог /boot, выполняем еще одну команду:

$ make unstall

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

Таблица 1. Необходимый набор пакетов для сборки

autoconf	grep	perl
automake	groff
bash	gzip	procinfo
bin86		procps
binutils	less	psmisc
bzip2		reiserfs-progs
diffutils	libtool
e2fsprogs	lilo	sh-utils
		shadow
file	make	sysklogd
fileutils	makedev	sysvinit
findutils	man-pages
flex	modutils	texinfo
gawk	ncurses	textutils
	netkitbase	util-linux
bison	net-tools
gettext	patch

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

$ rm -rf /stat

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

Начальное конфигурирование системы

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

Для установки системного времени создадим файл /etc/sysconfig/clock, содержащий всего одну строку:

UTC=0

Теперь часы компьютера будут отображать время вашего часового пояса – при условии, что значение времени в BIOS установлено верно.

Дадим компьютеру имя:

echo «HOSTNAME=my_linux» > /etc/sysconfig/network

Теперь разделы, которые система должна монтировать при загрузке, укажем в /etc/fstab:

# filesystem mount-point fs-type options dump fsck-order

/dev/hda5 / ext3 defaults 1 1

/dev/hda3 swap swap pri=1 0 0

proc /proc proc defaults 0 0

Вместо /dev/hda3 и /dev/hda5 напишите ваши разделы (корневой и swap), дополните файл при необходимости точками монтирования других разделов жесткого диска и CD-ROM.

Теперь сделаем нашу систему загружаемой.

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

$ exit

Уже в родительской ОС в файл /etc/lilo.conf добавляем следующее:

# LFS

image=/boot/bzImage

Label=lfs

Root=

Read-only

Понятно, что «/boot/bzImage» – это путь к скомпилированному вами ядру системы, а «partition» – раздел диска, где находится корневой каталог.

Если же вы не планируете пользоваться другими операционными системами и дистрибутивами Linux, то сразу переходите к настройке LILO в LFS.

В этом случае lilo.conf будет выглядеть примерно так:

boot=/dev/hda

Delay=40

Compact

Vga=normal

Root=/dev/hda1

Read-only

Image=/boot/zImage-2.6.12

Label=Linux

Сделайте необходимые изменения в зависимости от вашей конфигурации. Обновляем загрузчик командой:

$ /sbin/lilo –v

И, если все предыдущие этапы были выполнены правильно, мы окажемся в новой системе. Однако долгий этап «тонкой» настройки (отдельное внимание стоит уделить безопасности новой системы, ибо LFS по умолчанию выглядит довольно-таки незащищенным, как и всякая вновь установленная ОС) еще впереди. Зато собственноручно собранная версия Linux у вас уже есть.

Постскриптум

Герард Бикменс – не единственный, кому пришло в голову создать собственный Linux. Другой проект – BYOLinux, руководителем которого являлся Джонатан Торп (Jonatan Thorpe), на сегодняшний день свое развитие прекратил, хотя написанная имдокументация сохраняет актуальность и сейчас, но она не так детальна, как LFS-book и не переведена на русский. Главное отличие метода Джона в том, что библиотека glibc переносится из родительской системы в дочернюю без перекомпиляции, это не столь эффективно, но позволяет избежать многих проблем при сборке. Желание почувствовать себя конструктором ОС испытывают и некоторые пользователи FreeBSD.

Теперь такое вполне возможно – по адресу http://ezine.daemonnews.org/200302/fbsdscratch.html находится статья о сборке FreeBSD из исходников целиком – от distributions до портов, причем методом не похожим на обычный «rebuild» системы, но схожим с методом Герарда Бикменса. Что ж, теперь и у вас есть личная, уникальная система, созданная на базе Linux. В случае возникновения проблем ищите их решение в LFS-book, там все подробно описано. Также рекомендую с портала http://www.tldp.org скачать руководство Linux Network Administrator’s Guide, оно хоть и не относится непосредственно к LFS, но пригодится на этапе настройки системы. Не стоит забывать, что с каждой программой поставляются также различные man и info pages, также призванные облегчить жизнь линуксоида.

1. LFS-book на русском – http://multilinux.sakh.com/lfs .
   
2. Официальный портал проекта LFS – http://www.linuxfromscratch.org .
   
3. Портал ByoLinux – http://www.byolinux.org .
   
4. Cтатья о FreeBSD from scratch – http://ezine.daemonnews.org/200302/fbsdscratch.html .
   
5. Статья о компиляции ядра Linux – http://vikos.lrn.ru/MyLDP/kernel/kompil-2-6.html .
   
6. Байрак А. Обзор Knoppix 3.7 Russian Edition. – Журнал «Системный администратор», №3, март 2005 г. – 4-6 с. ().
   

Для начала обучитесь программированию.
Знание ассемблера необходимо; настоятельно рекомендуется также иметь понятие о других дополнительных языках программирования более низкого уровня, например, С.

Определитесь, на какое устройство вы хотите загрузить операционную систему.
Это может быть CD-диск, DVD-диск, устройство флэш-памяти, жесткий диск или другой компьютер.

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

Уточните, какую платформу процессора будет поддерживать ваша операционная система.
AI-32 и x86_64 являются двумя наиболее распространенными версиями для персональных компьютеров, так что их можно считать наилучшим выбором.

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

Выберите, собираетесь вы использовать свой собственный загрузчик или предварительно созданный унифицированный системный загрузчик Grand Unified Bootloader (GRUB).
Поскольку кодирование своей собственной программы загрузки требует обширных знаний в области компьютерного обеспечения и BIOS, это может отодвинуть график программирования действующего ядра.

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

• Чтобы собрать ОС с помощью кодов C или C++, вы, конечно, будете использовать то один компилятор, то другой. Это означает, что вы должны прочесть руководство/инструкции/документацию для выбранного компилятора C/C++, что поставляется в комплекте с программным обеспечением или доступно на веб-сайте дистрибьютора. Вам придется узнать множество сложных вещей о компиляторе, кроме того, для совершенствования C++ предстоит изучить его схему и ABI. Вы, как ожидается, поймете различные форматы исполнительных задач (ELF, PE, COFF, обычные бинарные и т.д.) и заметите, что собственный формат Windows, PE (.exe) защищен авторским правом.

Выберите интерфейс программирования приложений (API).
Одной из подборок хорошего API является POSIX, так как она хорошо документирован. Все системы Unix имеют, по крайней мере, частичную поддержку POSIX, так что было бы тривиально пристраивать программы Unix на вашу операционную систему.

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

Рассмотрите вопрос о разработке и работе в команде.
Таким образом, вам потребуется меньше времени на разрешение больших проблем, что позволит создать операционную систему лучшего качества за более короткие сроки.

Не стирайте ваш жесткий диск полностью.
Помните, форматирование диска необратимо очистит все ваши данные! Используйте GRUB или другой менеджер для дублированной загрузки вашего компьютера с другой ОС, пока ваша версия не будет полностью готова функционально.

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

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

Протестируйте вашу новую операционную систему на виртуальной машине.
Вместо перезагрузки компьютера каждый раз после внесения изменений или передачи файлов с рабочего компьютера тестовой машине вы можете использовать приложение для запуска ОС на виртуальной машине, в то время как ваша текущая ОС продолжает работать. Приложения VM включают в себя VMWare (которая также имеет сервер в свободном доступе), альтернативный открытый исходный код, Bochs, Microsoft Virtual PC (не совместим с Linux), а также XVM VirtualBox.

Выпустите релиз-версию.
Это позволит пользователям рассказать вам о возможных недостатках в вашей операционной системе.

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

• Когда разработка будет закончена, подумайте, хотите ли вы представить код в свободном доступе либо же установить частные права на него.
• Обязательно сделайте функции безопасности вашим основным приоритетом, если хотите, чтобы ваша система была жизнеспособной.
• Не начинайте проект разработки операционной системы с целью обучения программированию. Если вы не знаете C, C++, Pascal или какие-нибудь другие подходящие языки и свойства, в том числе типы указателя, операции с битами низкого уровня, переключение битов, встроенный ассемблер и т.д., – значит, еще не готовы для создания ОС.
• Просматривайте такие порталы, как OSDev и OSDever, которые помогут вам улучшить собственную операционную систему. Обратите особое внимание на то, что по большинству вопросов сообщество OSDev.org предпочитает, чтобы вы самостоятельно обращались к содержанию сайта, а не присоединялись к форуму. Если вы все же решили примкнуть к рядам форумчан, для этого должны быть определенные предпосылки. Вы обязаны досконально знать C или C++ и язык x86 ассамблер. Вы также должны понимать общие и комплексные понятия в программировании, такие как Linked Lists, Queues и т.д. Сообщество OSDev в своих правилах прямо говорит о том, что никто не собирается нянчить новых программистов. Если вы пытаетесь разработать ОС, само собой разумеется, что вы «бог» в области программирования. От вас также требуется прочесть руководство по работе с процессором касательно его архитектуры, выбранной вами; например, x86 (Intel), ARM, MIPS, PPC и т.д. Такой справочник по структуре процессора можно легко найти с помощью поиска в Google («Intel Manuals», «ARM manuals» и т.д.). Не регистрируйтесь на форуме OSDev.org, чтобы задавать очевидные вопросы. Это просто приведет к ответам вроде «Read the f*** ing Manual». Для начала вы должны попробовать почитать Википедию, пособия для различных инструментов, которые собираетесь использовать.
• Проверьте наличие потенциальных мертвых точек и других ошибок. Недочеты, тупики и другие проблемы могут повлиять на проект вашей операционной системы.
• Если вы хотите способ попроще, представьте дистрибутивы Linux — типа Fedora Revisor, Custom Nimble X, Puppy Remaster, PCLinuxOS mklivecd или SUSE Studio и SUSE KIWI. Тем не менее, создаваемая ОС принадлежит компании, которая первой представила этот сервис (хотя у вас есть права на ее свободное распространение, изменение и запуск, как вам нравится, под GPL).
• Хорошим решением будет создание совершенно нового раздела для разрабатываемой операционной системы.

Предупреждения

• Небрежное переписывание ОС на жесткий диск может повредить его полностью. Будьте осторожны
• У вас не получится полностью готовая система за две недели. Начните с загружаемой операционной системы, а затем переходите на более интересный материал.
• Если вы сделаете что-то опрометчивое, как, например, напишите беспорядочные байты в произвольных портах I/O, то уничтожите вашу ОС и можете (в теории) спалить ваше оборудование.
• Не ожидайте, что будет легко построить качественную операционную систему. Существует множество сложных взаимозависимостей. Например, для того, чтобы ОС была способна работать с несколькими процессорами, ваш диспетчер памяти должен иметь «блокирующие» механизмы для предотвращения доступа лишних процессоров в один и тот же ресурс одновременно. Используемые «блоки» предполагают наличие планировщика, чтобы убедиться, что только один процессор обращается к критическому ресурсу в любой момент времени, а все остальные находятся в режиме ожидания. Тем не менее, работа планировщика зависит от присутствия диспетчера памяти. Это пример зависимости от взаимоблокировки. Нет стандартного способа разрешить подобные проблемы; каждый создатель операционной системы, как ожидается, достаточно квалифицирован, чтобы найти свой собственный вариант их решения.

Источники

Что вам понадобится

• Компьютер
• Процессор, на котором собираетесь строить
• Достаточная оперативная память (ОЗУ) для виртуальной машины
• Основная ОС (используется для разработки исходного кода ассемблера (и др.), а также сборки и упаковки на ранних стадиях работы; в конечном итоге ваша собственная ОС станет первичной)
• Редактор цветного кода Syntax (применяется при отсутствии Integrated Development Environment)
• Компилятор
• CD/DVD привод

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

Мы будем предполагать, что читатель уже знаком с основами языков ассемблер и Си, а также элементарными понятиями архитектуры ЭВМ. То есть, мы не будем объяснять, что такое регистр или, скажем, оперативная память. Если вам не будет хватать знаний, вы всегда можете обратиться к дополнительной литературе. Краткий список литературы и ссылки на сайты с хорошими статьями есть в конце статьи. Также желательно уметь пользоваться Linux, так как все инструкции по компиляции будут приводиться именно для этой системы.

А теперь — ближе к делу. В оставшейся части статьи мы с вами напишем классическую программу «Hello World». Наш хеллоуворлд получится немного специфическим. Он будет запускаться не из какой-либо операционной системы, а напрямую, так сказать «на голом железе». Перед тем, как приступить непосредственно к написанию кода, давайте разберёмся, как же конкретно мы пытаемся это сделать. А для этого надо рассмотреть процесс загрузки компьютера.

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

Знайте же: за это отвечает система, которая есть на любом компьютере, и имя ей — нет, не Windows, типун вам на язык — называется она BIOS. Расшифровывается ее название как Basic Input-Output System, то есть базовая система ввода-вывода. Находится BIOS на маленькой микросхемке на материнской плате и запускается сразу после нажатия большой кнопки ВКЛ. У BIOS три главных задачи:

1. Обнаружить все подключенные устройства (процессор, клавиатуру, монитор, оперативную память, видеокарту, голову, руки, крылья, ноги и хвосты…) и проверить их на работоспособность. Отвечает за это программа POST (Power On Self Test – самотестирование при нажатии ВКЛ). Если жизненно важное железо не обнаружено, то никакой софт помочь не сможет, и на этом месте системный динамик пропищит что-нибудь зловещее и до ОС дело вообще не дойдет. Не будем о печальном, предположим, что у нас есть полностью рабочий компьютер, возрадуемся и перейдем к рассмотрению второй функции BIOS:
2. Предоставление операционной системе базового набора функций для работы с железом. Например, через функции BIOS можно вывести текст на экране или считать данные с клавиатуры. Потому она и называется базовой системой ввода-вывода. Обычно операционная система получает доступ к этим функциям посредством прерываний.
3. Запуск загрузчика операционной системы. При этом, как правило, считывается загрузочный сектор — первый сектор носителя информации (дискета, жесткий диск, компакт-диск, флэшка). Порядок опроса носителей можно задать в BIOS SETUP. В загрузочном секторе содержится программа, иногда называемая первичным загрузчиком. Грубо говоря, задача загрузчика — начать запуск операционной системы. Процесс загрузки операционной системы может быть весьма специфичен и сильно зависит от её особенностей. Поэтому первичный загрузчик пишется непосредственно разработчиками ОС и при установке записывается в загрузочный сектор. В момент запуска загрузчика процессор находится в реальном режиме.

Печальная новость: размер начального загрузчика должен быть всего 512 байт. Почему так мало? Для этого нам надо ознакомиться с устройством дискеты. Вот познавательная картинка:

На картинке изображена поверхность дискового накопителя. У дискеты 2 поверхности. На каждой поверхности есть кольцеобразные дорожки (треки). Каждый трек делится на маленькие дугообразные кусочки, называемые секторами. Так вот, исторически сложилось, что сектор дискеты имеет размер 512 байт. Самый первый сектор на диске, загрузочный сектор, читается BIOS»ом в нулевой сегмент памяти по смещению 0x7С00, и дальше по этому адресу передается управление. Начальный загрузчик обычно загружает в память не саму ОС, а другую программу-загрузчик, хранящуюся на диске, но по каким-то причинам (скорее всего, эта причина — размер) не влезающую в один сектор. А поскольку пока что роль нашей ОС выполняет банальный хеллоуворлд, наша главная цель — заставить компьютер поверить в существование нашей ОС, пусть даже и на одном секторе, и запустить её.

Как устроен загрузочный сектор? На PC единственное требование к загрузочному сектору — это содержание в двух его последних байтах значений 0x55 и 0xAA — сигнатуры загрузочного сектора. Итак, уже более-менее понятно, что нам нужно делать. Давайте же писать код! Приведённый код написан для ассемблера yasm .

section .
text

use16

org
0x7C00
; наша программа загружается по адресу 0x7C00

start:

mov
ax
,
cs

mov
ds
,
ax
; выбираем сегмент данных

mov
si
,
message

cld
; направление для строковых команд

mov
ah
,
0x0E
; номер функции BIOS

mov
bh
,
0x00
; страница видеопамяти

puts_loop:

lodsb
; загружаем очередной символ в al

test
al
,
al
; нулевой символ означает конец строки

jz
puts_loop_exit

int
0x10
; вызываем функцию BIOS

jmp
puts_loop

puts_loop_exit:

jmp
$ ; вечный цикл

message:

db
«Hello World!»
,
0

finish:

times 0x1FE
—
finish+
start db
0

db
0x55
,
0xAA
; сигнатура загрузочного сектора

Эта короткая программа требует ряда важных пояснений. Строка org 0x7C00 нужна для того, чтобы ассемблер (имеется в виду программа, а не язык) правильно рассчитал адреса для меток и переменных (puts_loop, puts_loop_exit, message). Вот мы ему и сообщаем, что программа будет загружена в память по адресу 0x7C00.
В строках

mov
ax
,
cs

mov
ds
,
ax

происходит установка сегмента данных (ds) равным сегменту кода (cs), поскольку в нашей программе и данные, и код хранятся в одном сегменте.

Далее в цикле посимвольно выводится сообщение «Hello World!». Для этого используется функция 0x0E прерывания 0x10 . Она имеет следующие параметры:
AH = 0x0E (номер функции)
BH = номер видеостраницы (пока не заморачиваемся, указываем 0)
AL = ASCII-код символа

В строке « jmp $ » программа зависает. И правильно, незачем ей выполнять лишний код. Однако чтобы компьютер опять заработал, придется перезагрузиться.

В строке « times 0x1FE-finish+start db 0 » производится заполнение остатка кода программы (за исключением последних двух байт) нулями. Делается это для того, чтобы после компиляции в последних двух байтах программы оказалась сигнатура загрузочного сектора.

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

Рано или поздно каждый пользователь Линукса задумывается над созданием собственного дистрибутива. Некоторые аргументируют это тем, что можно «все настроить под себя». Другие сетуют на то, что среди уже представленных дистрибутивов в Ветке нет идеального. А у них, якобы, есть суперконцептуальные идеи для собственной системы. Зачем я всю эту психологию затеял? Для того, чтобы сразу перекрыть кислород играющимся с Линуксом новичкам, которым делать нечего. Если уж задумались над созданием ОС, думайте до конца. Итак,

Я хочу создать ОС на базе Linux.

Сразу предупреждаю: был бы XVIII век, всех тех, кто для основы своей будущей системы выбирает другой развитый дистрибутив (и, не дай Бог, популярный…) ждала бы виселица. Пост именно про создание системы с нуля, а значит, всякие Slax и Linux Mint мы трогать не будем.

Шаг 1. Выбор носителя

Вариантов немного: либо ваша ОС запускается с LiveCD, либо с жесткого диска, либо с флеш-устройства. Сразу оговорюсь: не скажу в посте ни слова про жесткий диск, потому что гораздо удобнее создавать гибкий дистрибутив из серии «все свое ношу с собой», либо залоченный дистрибутив на оптическом диске. Если вы научитесь создавать LiveCD или LiveUSB систему, с установкой на жесткий диск проблем не будет.

На всякий случай, приготовьте чистую флешку, CD-диск, и установите, наконец, Virtualbox.

Шаг 2. Компиляция ядра

По поводу выхода третьего ядра Linux, этот шаг воодушевляет на дальнейшие разработки… Итак, нам нужны исходники ядра. Каждый пользователь знает, что их можно достать на сайте kernel.org. Ни в коем случае, слышите?, никогда не прикручивайте к своей системе постороннее ядро, скомпилированное не вами!

Поскольку лень моя зашкаливала, я создал папку /linuxkernel и распаковал туда архив с исходниками. Залогинившись под рутом, я сделал следующее:

cd /linuxkernel
make menuconfig

В принципе, ядро можно конфигурировать тремя способами: make config (диалоговая конфигурация), make menuconfig (псевдографическая конфигурация через ncurses), а также make xconfig (графическая конфигурация). Суть в том, что make config испортит вам настроение надолго, т.к. он задаст все возможные вопросы по всем аспектам всех тем. Проблема с make xconfig встречается не у всех, но вот у меня встречалась и встречается. Если приспичило сделать через X, разбирайтесь сами. Оптимальный вариант — make menuconfig. Эта штука откроет вам псевдографический интерфейс, через который вы сможете настроить ядро на свой лад. Штука требует библиотеки ncurses, которая легко устанавливается.

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

Однако, направить вас все же придется. Перейдите по адресу File Systems —> и поставьте необходимые звездочки. Буква M означает, что поддержка того или иного драйвера осуществляется с помощью подключения к ядру внешнего модуля (ненавижу их!). Нам понадобится также поддержка isofs, для чтения дисков. File Systems —> CD-ROM/DVD Filesystems —> ISO 9660 CDROM file system support. Можно еще поддержать древнедосовские системы.

Чмошные разработчики Mandriva забыли разрешить File systems —> DOS/FAT/NT Filesystems —> NTFS write support, и на одном из их дистрибутивов я мучился с доступом к древневиндовскому разделу.

Посмотрите Processor type and features —> Processor family, мне порекомендовали выбрать Pentium-MMX.

Еще поройтесь в Device Drivers, полезно. Можете шутки ради понавыбирать там все и скомпилировать ядро весом > 50 Мб.

Далее. Ядро после загрузки себя должно загружать, собственно, систему. Либо из скомпилированных в себе файлов (используются во встраиваемых системах), либо из CPIO архива, сжатого чем-нибудь, либо из Initrd. Здесь вам не DOS, здесь не получится сразу сослаться на какой-нибудь init»овый файл в корневом каталоге диска или флешки. На самом деле получится, не слушайте дядю Анникса! Неправильно это, хоть в Интернете по этому поводу уже нехилая полемика ведется. В своей системе мы будем использовать initrd, т.к. это удобно, и не вызовет нецензурных выражений от сторонних разработчиков, в отличие от CPIO архива.

Ах, да, скомпилируйте ядро командой

Если у вас x86, найдете его по адресу /linuxkernel/arch/x86/boot/bzImage.

Для суровых челябинских программистов можно использовать Кросс-компайлинг…

Создание Ramdisk.

Теперь нам нужен initrd с установленной там простейшей оболочкой. Мы будем использовать busybox, потому что эта няша может все. Способ мы украдем у Роберто де Лео, создателя Movix (я бы даже уважать его начал, если бы не запредельная любовь к Perl):

dd if=/dev/zero of=/dev/ram0 bs=1k count=5000 — Создаем Ramdisk в оперативной памяти нашего компьютера.
mke2fs -m0 /dev/ram0 5000 — Форматируем Ramdisk в системе Ext2
mkdir /distro — Создаем папку
mount /dev/ram0 /distro — Монтируем в папку /distro

Все, теперь у нас есть Ramdisk, емкостью в 5 Мб. Можно и больше, только не нужно. В отличие от Томаса Матеджисека, я не собираюсь пичкать initrd модулями в Squashfs, сжатыми LZMA. Все, что необходимо, будет скомпилировано вместе с ядром. Да, это не очень логично и правильно, но мороки в сто раз меньше. А специально для тех, кто осуждает такой подход, можно разрешить опцию модульности в ядре: Enable loadable module support.

В нашем Ramdisk»е, смонтированном в /distro, есть такая папка, lost+found. Это потому, что мы отформатировали его в ext2. Ни в коем случае нельзя ее удалять, хоть она здесь вряд ли поможет, образ-то фиксированный. Нам бы busybox сначала поставить…

Установка Busybox

Вот почему у таких классных проектов такие отстойные сайты? Хотя… это уже не суть важно, если исходники скачаны и успешно распакованы в папку /busybox.

Сконфигурировать busybox можно так же:

cd /busybox
make menuconfig

Если вы еще не поняли, что это, объясню. Busybox заменяет тонны UNIX приложений, хранящихся в папках /bin, /sbin, /usr/bin, /usr/sbin. Вместо этого, создается только одно приложение: /bin/busybox, а на него создается куча ссылок в указанных выше папках. Установим busybox следующей командой:

make CONFIG_PREFIX=/distro install

Еще Busybox создаст файлы /sbin/init и зачем-то /linuxrc, чтобы ваша система корректно запустилась. Но не все необходимые папки были созданы. Так что завершаем все руками и создаем:

/distro/etc
/distro/lib
/distro/dev
/distro/mnt
distro/proc
/distro/root
/distro/tmp
/distro/root

Если что забыл — вспомните, т.к. директории эти забыть сложно.

Все бы хорошо, вот только busybox для работы требует библиотеки, которые нужно скопировать в наш дистрибутив. Очень легко узнать, какие:

ldd /distro/bin/busybox

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

При копировании библиотек можно отсекать отладочную информацию (так Роберто советует):

objcopy —strip-debug откуда куда

Делаем из Линукса Линукс

Надо создать несколько системных текстовых файлов:

Нам нужен /etc/inittab. Удивлю вас: в начале жизни система даже не знает, что такое Root. У нас даже пользователь безымянный, но вот файл общесистемных низкоуровневых фич (ОНФ) должен присутствовать. Пилотное содержание файла следующее:

# Самый первый запускаемый файл, /sbin/init потом.
::sysinit:/etc/rc.d/rc.S

# Запустить оболочку в консоли.
::respawn:-/bin/sh

# Команды, выполняемые перед выключением и перезагрузкой.
::shutdown:/sbin/swapoff -a >/dev/null 2>&1
::shutdown:/bin/umount -a -r >/dev/null 2>&1

Следующий файл — /etc/fstab. Это таблица, в которой описано, что и куда монтировать при загрузке. Вещь бесполезная! Нам нужно обязательно смонтировать proc, иначе вообще ничего работать не будет, так что в файле пишем:

none /proc proc defaults 0 0

Для mount нужен также файл /etc/mtab. Создайте его и оставьте пустым.

Но mount сделает все необходимое только тогда, когда мы явно его об этом попросим. А просить мы будем в том самом первозагрузочном файле /etc/rc.d/rc.S (rc.d — папка). Вежливо попросим:

/bin/mount -av -t nonfs

Еще нам необходим файл профиля (b)(a)sh, тут вообще раздолье для фантазии. Создаем файл /etc/profile и заполняем следующим:

PATH=»$PATH:/bin:/sbin:/usr/bin:/usr/sbin:»
LESS=-MM
TERM=linux
HOME=/root
PS1=»> «
PS2=»> «
ignoreeof=10
export PATH DISPLAY LESS TERM PS1 PS2 HOME ignoreeof

Понадобится также файл /etc/shell, в котором указано, что есть оболочка:

/bin/sh
/bin/ash
/bin/bash

Вот собственно и все. Можно записывать наш Ramdisk в файл.

mkdir /os — папка для «готового».
umount /dev/ram0 — размонтируем кусочек оперативной памяти.
dd if=/dev/ram0 of=/os/initrd bs=1k count=5000 — создаем файл.
gzip /os/initrd — сжимаем файл initrd

Создание загрузочной флешки

«Финишная прямая» нашей маленькой разработки. Берем флешку, вставляем, форматируем в vfat (можно и в ext, но не забывайте, что еще не все пользователи Windows застрелились).

На флешке создаем папку boot, в ней папки initrd и kernel.

Из папки /os копируем сжатый Ramdisk в папку boot/initrd на флешке, называем «main.gz». Из папки с исходниками ядра копируем bzImage в папку boot/kernel на флешке, называем «main.lk». Достаем файлы загрузчика Syslinux (в Интернете, либо из другого дистрибутива: тут не принципиально), а именно syslinux.bin, syslinux.boot, syslinux.cfg. Копируем их в корневой каталог нашей флешки. В файле syslinux.cfg пишем что-то подобное:

Тем самым мы поддержали кастомные initrd и ядро, которые, эксперимента ради, можно подключить к нашему дистрибутиву.

Узнаем, каким девайсом в системе является наша флешка (можно запустить mount без параметров и посмотреть). Это либо /dev/sdb1, либо /dev/sdc1, либо /dev/sdd1. Стоит отмонтировать флешку перед началом установки.

Устанавливаем syslinux (если пакета в системе нет, apt-get install syslinux):

syslinux -d путь_к_устройству

В корневом каталоге флешки должен появиться файл ldlinux.sys. Если он есть, значит syslinux.bin, syslinux.boot больше не нужны.

Как настроить BIOS на загрузку из флешки, я вам рассказывать не буду — это легко. Скажу только, что очень удобно создать папку /boot/initrd/init, в которую можно будет смонтировать /boot/initrd/main, для последующей работы с ним. Только не забудьте разжимать и сжимать его gzip»ом.

Ну вот и все.

Как-бы я только что рассказал вам, как создать с нуля систему на Linux. Легко, не правда ли? Далее вы можете редактировать скрипт /sbin/init, ведь у вас еще много работы! Вы должны будете написать скрипт для монтирования флешки, который делает chroot в корневой каталог. В противном случае, вы вынуждены будете работать с ReadOnly разделом, величиной в 5 Мб. Но это уже совсем другая история.

Если подходить по существу…

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

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

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

Для РС надо на асме писать бутлоадер, который будет вызываться BIOS и кой должен, не превышая четырёх с копейками сотен байт, что-то сделать и запустить основную ОС — передать управление основному коду, который в ближайшей же перспективе можно писать уже и на С.

Для ARM надо на асме делать таблицу прерываний (сброс, ошибки разные, прерывания IRQ, FIQ и пр.) и передачу управления в основной код. Хотя, во многих средах разработки такой код для почти любого контроллера имеется.

То есть, необходимо для этого:

1. Знать ассемблер целевой платформы.
2. Знать архитектуру процессора и всякие служебные команды и регистры, чтобы настроить его для работы в нужном режиме. В РС это переход в защищённый режим, например, или в 64битный режим… В ARM — настройка тактирования ядра и периферии.
3. Знать, как именно будет запускаться ОС, куда и как нужно пихать свой код.
4. Знать язык С — большой код на асме написать затруднительно без опыта, поддерживать его будет ещё труднее. Посему надо ядро писать на С.
5. Знать принципы работы ОС. Ну, книжек на русском языке по этой теме много всяких, правда, не знаю, все ли они хорошие.
6. Иметь много-много терпения и усидчивости. Ошибки будут и их надо будет искать и исправлять. А ещё надо будет очень много читать.
7. Иметь много-много времени.

Далее. Допустим, вы что-то написали. Надо это дело тестировать.
Либо надо устройство физическое, на коем будут идти эксперименты (отладочная плата, второй компьютер), либо эмулятор его. Второе обычно использовать и проще, и быстрее.
Для PC, например, VMWare.

Статей по этой теме в интернете тоже достаточно, если хорошо поискать. А также есть множество примеров готовых ОС с исходниками.

Даже можно при большом желании посмотреть исходники старого ядра NT-систем (Windows), как отдельно (кое микрософтом выложено, с комментариями и разного рода справочными материалами), так и в совокупности со старыми же ОС (утекло).