WikiDer > Cosmos (операционная система)

Космос
	Скриншот ОС, созданной с помощью COSMOS, демонстрирующий возможность создания графического интерфейса.
Разработчик	Космос Проект
Написано в	C #, ИКС#
Рабочее состояние	Активный
Исходная модель	Открытый исходный код
Последний релиз	Выпуск 20200708/8 июля 2020 г.; 4 месяца назад
Доступно в	английский
Ядро тип	Монолитный
Лицензия	BSD
Официальный веб-сайт	www.gocosmos.org

Cosmos (operating system)

Управляемая операционная система с открытым исходным кодом C # (Космос) это Инструментарий для строительства операционные системы, написано в основном на языке программирования C # и небольшие суммы высокого уровня язык ассемблера с именем X #. Космос это backronym,^[1] в этом акроним был выбран до смысла. это программное обеспечение с открытым исходным кодом выпущен под Лицензия BSD.

Космос включает в себя Компилятор AOT названный IL2CPU переводить Общий промежуточный язык (CIL) в собственные инструкции. Cosmos компилирует пользовательские программы и связанные с ними библиотеки используя IL2CPU для создания загрузочный собственный исполняемый файл, который можно запустить без поддержки. Полученный результат можно загрузить из флешка, CD-ROM, по сети через Среда выполнения перед загрузкой (PXE) или внутри виртуальная машина. Последние выпуски также позволяют развертывать на определенных x86 встроенные устройства через универсальную последовательную шину (USB). Хотя C # является основным языком, используемым разработчиками (как на сервере, так и конечные пользователи Космоса), многие Языки интерфейса командной строки могут использоваться, если они компилируются в чистый CIL без использования Сервисы вызова платформы (P / Invokes). Cosmos в основном предназначен для использования с .NET Framework, с Мононуклеоз поддержка в работе.

По состоянию на 2016 год^{[Обновить]}, Cosmos не стремится стать полноценной операционной системой, а скорее Инструментарий чтобы позволить другим разработчикам просто и легко создавать свои собственные операционные системы, используя .сеть рамки. Он также функционирует как уровень абстракции, скрывая большую часть внутренней работы оборудования от возможного разработчика.

Предыдущие версии Cosmos были выпущены в Вехи, последней из которых является Milestone 5 (выпущена в августе 2010 г.). Совсем недавно проект переключился на простое обозначение новых выпусков после номера последнего коммита. Релизы Cosmos делятся на два типа: Userkit, а Devkit. Userkit »- это предварительно упакованный выпуск, который обновляется нерегулярно по мере добавления новых и улучшенных функций. Userkit обычно считается стабильным, но не включает недавние изменения и может не иметь функций. Devkit относится к исходный код Космоса и должны быть построены вручную. Наборы разработчика обычно нестабильны, так как могут содержать незаконченный или непроверенный код. Devkit можно приобрести на GitHub.^[1] и использует Git в качестве системы управления версиями. Большая часть работы над Cosmos в настоящее время направлена на улучшение отладчик функциональность и Visual Studio интеграция. Ядро работа направлена на реализацию файловые системы, управление памятьюи разработка надежного сетевого интерфейса. Syslinux служит проектом загрузчик.

Разработка с Cosmos

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

Интеграция с Visual Studio

Ключевой особенностью Cosmos, которая отличает его от других операционных систем такого типа, является его тесная интеграция с Microsoft Visual Studio. Код можно написать, составлен, отлаженный, и полностью пройти через Visual Studio, всего несколькими нажатиями клавиш. Cosmos больше не поддерживает Visual Studio 2015 или же Visual Studio 2017, теперь поддерживает только Visual Studio 2019.

Отладка

Cosmos можно легко отлаживать через Visual Studio при работе через PXE или на виртуальной машине. Присутствуют многие стандартные функции отладки, такие как точки останова, трассировка и ведение журнала. Кроме того, отладка может выполняться через последовательные кабели при работе на физическом оборудовании. При работе в VMWare Cosmos поддерживает пошаговое выполнение и точки останова даже во время работы операционной системы.

Бег

Cosmos использует виртуализацию, чтобы ускорить разработку, позволяя разработчикам тестировать свои операционные системы, не перезагружая свои компьютеры так часто. По умолчанию используется VMWare Player из-за простоты использования с точки зрения интеграции с проектом. Также поддерживаются другие среды виртуализации, такие как Bochs и VirtualPC. Также может быть сгенерирован ISO-образ диска, который можно записать на USB-накопитель, CD-ROM или аналогичный носитель.

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

Процесс компиляции

IL2CPU

Для компиляции .NET CIL в язык ассемблера разработчики Cosmos создали раньше времени компилятор с именем IL2CPU, предназначенный для анализа CIL и вывода x86 коды операций. (IL To CPU) - это Компилятор AOT который написан с использованием Общий промежуточный язык совместимый язык (C #). Это переводит Общий промежуточный язык к Машинный код.

ИКС#

ИКС# низкоуровневый язык программирования разработан для x86 архитектура процессора как часть операционной системы Cosmos для облегчения разработки операционной системы. X # призван принести некоторые из C-подобный язык синтаксис к язык ассемблера. Вначале X # был помощником для отладки сервисов Cosmos. Компилятор X # - это Открытый исходный код консоль интерфейс программы с нетипичной архитектурой. Он анализирует строки кода на токены и сравнивает их с шаблонами. Наконец, согласованные шаблоны кода X # переводятся в синтаксис Intel сборка x86, обычно для NASM компилятор. В первых версиях операция X # была в основном 1: 1 с кодом сборки, но не была причиной написания компилятора X #.

Синтаксис

Синтаксис X # прост. Несмотря на то, что он похож на C, X # синтаксис отличается и строже.

Константы

X # поддерживает определение именованных констант, объявленных вне функций. Определение числовой константы аналогично C ++ - например,

const я = 0

. Ссылка на константу в другом месте требует # перед именем - "#я", например.

Чтобы определить нить константа, одинарные кавычки ('') используются. Чтобы использовать одинарную кавычку в строковой константе, ее необходимо экранировать, поместив перед ней обратную косую черту, как 'Я так счастлив'. Строки X # нулевое завершение.
Шестнадцатеричные константы начинаются со знака доллара ($), а затем - константа. (8000 долларов США).
Десятичные константы не украшены, но могут не начинаться с 0.
Двоичные и восьмеричные константы пока не поддерживаются.

Этикетки

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

CodeLabel1:    идти к CodeLabel2:

Пространства имён

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

пространство имен ПЕРВЫЙ// Все имена переменных или констант будут иметь префикс FIRST и знак подчеркивания. Следовательно, настоящее полное имя указанной ниже переменной// это FIRST_aVar.вар aVarпространство имен ВТОРОЙ// Не проблема назвать другую переменную aVar. Его настоящее имя - SECOND_aVar.вар aVarпространство имен ПЕРВЫЙ// Этот код теперь возвращается в пространство имен FIRST до конца файла.

Функции

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

функция xSharpFunction {    // код функции}

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

функция xSharpFunction {    EAX = $10    другая функция(EAX);    возвращаться}функция другая функция {    // код функции}

В возвращаться ключевое слово возвращает выполнение на адрес возврата EIP, сохраненный в стеке.

Арифметические и побитовые операции

X # может работать с тремя низкоуровневыми структурами данных: регистры, то куча и объем памяти, на разных портах. Регистры являются основой всех обычных операций для X #. Один регистр можно скопировать в другой, написав DST = SRC в отличие от mov или загрузить / сохранить инструкции. Регистры можно увеличивать или уменьшать так же легко. Арифметические операции (сложение, вычитание, умножение, деление) записываются как dest op src куда src константа, переменная или регистр, и dest одновременно является операндом и местом, где сохраняется результат.

Примеры присваивания и арифметических операций показаны ниже.

ESI = 12345              // присваиваем 12345 ESIEDX = #constantForEDX    // присваиваем #ConstantForEDX EDXEAX = EBX                // перемещаем EBX в EAX => mov eax, ebxEAX--                    // уменьшаем EAX => dec eaxEAX++                    // увеличиваем EAX => inc eaxEAX + 2                  // добавляем 2 к eax => добавляем eax, 2EAX - $80                // вычесть 0x80 из eax => sub eax, 0x80BX * CX                  // умножаем BX на CX => mul cx - деление, умножение и по модулю должны сохранять регистрыCX / BX                  // делим CX на BX => div bxCX мод BX                // остаток от CX / BX до BX => div bx

Регистр сдвига и качения аналогичен C.

DX << 10  // сдвиг влево на 10 битCX >> 8   // сдвиг вправо на 8 битEAX <~ 6  // повернуть влево на 6 битEAX ~> 4  // повернуть вправо на 4 бита

Другие побитовые операции аналогичны арифметическим операциям.

DL & $08     // выполнить побитовое И для DL с 0x08 и сохранить результат в DLCX | 1       // установить младший бит CX в 1 (сделать его нечетным)EAX = ~ECX   // выполнить побитовое НЕ на ECX и сохранить результат в EAXEAX ^ EAX    // стираем EAX, выполняя XOR с самим собой

Куча

Управление стеком в X # выполняется с помощью + и - префиксы, где + помещает регистр, значение, константу или все регистры в стек и - выдает значение в какой-то регистр. Все константы помещаются в стек как двойные слова, если не указано иное (передача одиночных байтов не поддерживается).

+ESI                   // нажимаем esi-EDI                   // вставляем в edi+Все                   // сохраняем все регистры => пушад-Все                   // загружаем все регистры => popad+$1badboo2             // помещаем 0x1badboo2 в стек+$кафе в качестве слово         //          \/+$младенец в качестве слово         // нажимаем 0xcafebabe+#ВидеоПамять          // вставляем значение константы VideoMemory

Переменные

Переменные определяются в пространствах имен (поскольку фреймы стека отсутствуют, локальные переменные не поддерживаются) с использованием вар ключевое слово. Массивы можно определить, добавив тип и размер массива в конце объявления. По умолчанию переменные и массивы обнуляются. Чтобы ссылаться на значение переменной, оно должно начинаться с точки. С префиксом @ будет ссылаться на адрес переменной.

пространство имен XSharpVariablesвар zeroVar                      // переменной будет присвоен нольвар myVar1 = $f000beef           // переменной будет присвоено значение 0xf000beefвар someString = 'Привет XSharp!' // переменной будет присвоено 'Hello XSharp!  0',вар буфер байт[1024]            // переменной размером 1024 байта будет присвоено 1024 нулевых байта...EAX = .myVar1                    // перемещает значение myVar1 (0xf000beef) в EAXESI = @.someString               // перемещает адрес someString в ESICL = .someString                 // перемещает первый символ someString ('H') в CL.zeroVar = EAX                   // присваивает нулевую переменную значению EAX

X # может получить доступ к адресу с указанным смещением, используя квадратные скобки:

вар someString = 'Привет XSharp!' // переменная будет присвоена 'Hello XSharp!  0'...ESI = @.someString       // загружаем адрес someString в ESICL = 'B'                 // устанавливаем CL в 'B' (перезаписываем 'H' в начале)CH = ESI[1]              // перемещаем второй символ ('E') из строки в CHESI[4] = $00             // конец строки// Значение someString будет 'Bell' (или 'Bell  0 XSharp!  0')

Сравнение

Есть два способа сравнения значений: чистое сравнение и сравнение if.

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

Вот два способа записать (медленную) длину строки X # (Strlen) функция:

// Метод 1: использование чистого сравненияфункция Strlen {    ESI = ESP[4] // получаем указатель на строку, переданную как первый аргумент    ECX ^ ECX    // очистить ECXПетля:    AL = ESI[ECX]// получаем следующий символ    AL ?= 0      // это 0? сохранить в FLAGS    если = возвращаться  // если ZF установлен, возвращаем    ECX++        // иначе увеличиваем ECX    идти к Петля    // петля...// Способ 2: использование ifфункция Strlen {    ESI = ESP[4]    // получаем указатель на строку, переданную как первый аргумент    ECX ^ ECX       // очистить ECXПетля:    AL = ESI[ECX]    если AL = 0 возвращаться// AL = 0? возвращаться    ECX++    идти к Петля       // петля....}

Доступны шесть операторов сравнения: < > = <= >= !=. Эти операторы можно использовать как в сравнениях, так и в циклах. Обратите внимание, что есть также побитовое И оператор, который проверяет биты:

AL ?& $80      // тест AL MSBесли = возвращаться    // если ZF равен 0, тестовая инструкция привела к 0 и старший бит не установлен.

Написание кода Cosmos

Операционная система, созданная с помощью Cosmos, разрабатывается аналогично любой консольной программе .NET C #. Дополнительные ссылки сделаны в начале программы, которые предоставляют доступ к библиотекам Cosmos. Эти библиотеки переопределяют системные библиотеки, обычно используемые в консольных программах C #, поскольку полученный двоичный файл не будет работать при установке Майкрософт Виндоус.

Пользовательский комплект и Visual Studio

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

Составление проекта

После завершения кода его можно скомпилировать с помощью компилятора .NET. Это преобразует приложение из исходного исходного кода (C # или иначе) в Общий промежуточный язык (CIL), родной язык .NET Framework. Затем запускается приложение, в котором отображается окно Cosmos Builder, в котором разработчику предлагаются параметры, которые точно определяют способ компиляции проекта. Эти параметры включают способ загрузки проекта - через эмуляторы, такие как Quick Emulator (QEMU), Виртуальный ПК, и VMWare, писать в образ диска (ISO) файл, который позже может быть записан в CD-ROM, или через Среда выполнения предварительной загрузки (PXE) сетевая загрузка, а также параметры отладки с использованием встроенных функций Cosmos. отладчик, и другие варианты.

Когда пользователь выбрал желаемые параметры, он нажимает кнопку «Построить». Это вызывает IL2CPU компилятор, который систематически просматривает код CIL всех приложений (за исключением кода компилятора Cosmos), преобразовывая его в язык ассемблера для выбранной архитектуры процессора. По состоянию на 2016 год^{[Обновить]}, Только x86 поддерживается. Затем Cosmos вызывает выбранный ассемблер для преобразования этого кода языка ассемблера в собственный. центральное процессорное устройство (ЦПУ) код операции. Наконец, активируется желаемый вариант вывода, будь то запуск эмулятора, запуск механизма PXE или создание ISO образ диска файл из бинарный код код операции.

Варианты отладки

Cosmos предлагает несколько вариантов того, как развернуть полученную ОС и как отлаживать выход.

Виртуализация

Экран загрузки Cosmos по умолчанию, как показано в QEMU.

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

Образы дисков

Эта опция записывает операционную систему в образ диска (ISO) файл, который можно загрузить в некоторые эмуляторы (например, Bochs, QEMU или чаще VMware) или написано CD-ROM и загрузился на реальном оборудовании. Этот вариант также позволяет развертывать на запоминающем устройстве USB, например, флешка, для загрузки на устройствах, которые могут не иметь дисковода оптических дисков. Поскольку сети еще нет, отладка не поддерживается с помощью этого варианта развертывания.

Сетевая загрузка PXE

Эта опция позволяет операционной системе загружаться на реальном оборудовании. Данные отправляются через локальная сеть (LAN) в клиент машина. Для этого требуются два компьютера: один в качестве клиентского компьютера (на котором загружается ОС) и один в качестве сервера (обычно это машина для разработки). Также требуется сеть, соединяющая два компьютера, клиентская машина с сетевая карта, и базовая система ввода / вывода (BIOS), который может загружаться по протоколу PXE. По состоянию на 2016 год^{[Обновить]}, отладка по сети не поддерживается.

Ассемблер Cosmos

Команда проекта Cosmos также создала ассемблер который призван в конечном итоге стать основным ассемблером для системы Cosmos. Однако ассемблер по-прежнему неэффективен и медленен, поэтому Сетевой ассемблер Вместо этого используется (NASM).

Смотрите также

внешняя ссылка

Освещение новостей

[GitHub-1] а ^б Сайт Cosmos: репозиторий проекта на GitHub

[1]

Navigation