Ос на ассемблере исходники: Маленькая ОС с нуля на C++ и ассемблере / Хабр

Содержание

Маленькая ОС с нуля на C++ и ассемблере / Хабр

Сразу говорю, не закрывайте статью с мыслями «Блин, еще один Попов». У него всего-то слизанная Ubuntu, а у меня все с нуля, включая ядро и приложения. Итак, продолжение под катом.

Группа ОС: вот.
Сначала я кину вам один скриншот.

Больше их нет, а теперь поподробнее о том, зачем я ее пишу.

Был теплый апрельский вечер, четверг. Я еще с детства мечтал написать ОС, как вдруг подумал: «Я же теперь знаю плюсы и асм, чего бы не воплотить мою мечту?». Загуглил сайты по этой тематике и нашел статью с Хабра: «Как начать и не бросить писать ОС». Спасибо ее автору за ссылку на OSDev Wiki внизу. Я зашел туда и начал работу. Там были в одной статье все данные о минимальной ОС. Я начал собирать кросс-gcc и binutils, а потом все переписал оттуда. Видели вы бы мою радость, когда я увидел надпись «Hello, kernel World!» Я прямо со стула подпрыгнул и понял — я не сдамся. Я написал «консоль» (в кавычках, у меня не было доступа к клавиатуре), но потом решил написать оконную систему. В итоге она заработала, но доступа к клавиатуре у меня не было. А потом я решил придумать название, опираясь на X Window System. Загуглил Y Window System — она есть. В итоге назвал Z Window System 0.1, входящая в OS365 pre-alpha 0.1. И да, ее не видел никто, кроме меня самого. Потом я понял, как реализовать поддержку клавиатуры. Скрин самой первой версии, когда еще не было ничего, даже оконной системы:

В ней даже не двигался курсор текста, как вы видите. Затем я написал парочку простых приложений на основе Z. И вот релиз 1.0.0 alpha. Там были много вещей, даже меню системы. А файловый менеджер и калькулятор просто не работали.

Далее 1.0.1 с текстовым редактором, 1.0.2 с граф. режимом 640×480, 1.0.3 с рабочим столом, 1.0.4 с русским языком, 1.0.5 с фиксами и чем-то еще, 1.0.6 с часами, а вот на 1.1 остановимся поподробнее.

Меня прямо терроризировал друг, которому важны одни красивости (Митрофан, сорри). Говорил «Запили VBE-режим 1024*768*32, запили, запили! Ну запили!». Ну я уже устал его выслушивать и все-таки запилил его. О реализации ниже.

Я сделал все моим загрузчиком, а именно GRUB’ом. С его помощью можно задать графический режим без осложнений путем добавления нескольких магических строчек в заголовок Multiboot.

.set ALIGN,	1<<0
.set MEMINFO,	1<<1
.set GRAPH,     1<<2
.set FLAGS,	ALIGN | MEMINFO | GRAPH
.set MAGIC,	0x1BADB002
.set CHECKSUM, 	-(MAGIC + FLAGS)
.align 4
.long MAGIC
.long FLAGS
.long CHECKSUM
.long 0, 0, 0, 0, 0
.long 0 # 0 = set graphics mode
.long 1024, 768, 32 # Width, height, depth

А потом из структуры информации Multiboot я беру адрес фреймбуфера и разрешение экрана и пишу туда пиксели. VESA все сделали очень замороченно — цвета RGB надо вводить в обратном порядке (не R G B, а B G R). Я несколько дней не понимал — почему пиксели не выводятся!? В итоге я понял, что забыл поменять значения 16 цветовых констант с 0…15 на их RGB-эквиваленты. В итоге релизнул, заодно запилил градиентный фон. Потом я сделал консоль, 2 приложения и релизнул 1.2. Ах да, чуть не забыл — скачать ОС можно на сайте (хабраэффект, он лежит).
И да, вы не поверите, но мне 11 лет.
Продолжение следует…

Полет «Колибри». На что способна ОС, целиком написанная на ассемблере — «Хакер»

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

Развитие «Колибри» шло довольно быстро вплоть до 2009 года. Птичка научилась летать на разном железе, минимально требуя первый «Пентиум» и восемь мегабайт оперативной памяти. Минимальные системные требования «Колибри» таковы:

  • ЦП: Pentium, AMD 5×86 или Cyrix 5×86 без MMX с частотой 100 МГц;
  • ОЗУ: 8 Мбайт;
  • видеокарта: VESA-совместимая с поддержкой режима VGA (640 × 480 × 16).

Современная «Колибри» — это регулярно обновляемые «ночные сборки» последней официальной версии, вышедшей в конце 2009 года. Мы тестировали билд 0.7.7.0+ от 20 августа 2017 года.

WARNING

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

Изменения в ночных сборках хоть и невелики, но за годы их накопилось достаточно. Обновленная «Колибри» может писать на разделы FAT16–32 / ext2 — ext4 и поддерживает другие популярные файловые системы (NTFS, XFS, ISO-9660) в режиме чтения. В ней появилась поддержка USB и сетевых карт, был добавлен стек TCP/IP и звуковые кодеки. В общем, в ней уже можно что-то делать, а не просто посмотреть разок на сверхлегкую операционку с GUI и впечатлиться скоростью запуска.

KolibriOS X-edition

Как и предшествующие версии, последняя «Колибри» написана на flat assembler (FASM) и занимает одну дискету — 1,44 Мбайт. Благодаря этому ее можно целиком разместить в какой-нибудь специализированной памяти. Например, умельцы записали KolibriOS прямо во Flash BIOS. Во время работы она может целиком размещаться в кеше некоторых процессоров. Только представь: вся операционка вместе с программами и драйверами кеширована!

INFO

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

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

Мгновенное подключение к сети

Одна проблема — протокол HTTPS не поддерживается встроенным в «Колибри» браузером. Поэтому сайт Xakep.ru посмотреть в ней не удалось, так же как открыть страницы Google, Yandex, Wikipedia, «Сбербанка»… собственно, никакой привычный адрес. Все давно перешли на защищенный протокол. Единственный сайт с олдскульным чистым HTTP, который мне попался, — это «портал Правительства России», но и он выглядел в текстовом браузере не лучшим образом.

Текстовый браузер работает только с HTTP

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

Выбор разрешения

Перечень доступных вариантов невелик, и нужного разрешения в нем может не оказаться. Если у тебя видеокарта с ГП AMD (ATI), то можно сразу добавить кастомные настройки. Для этого нужно загрузчику ATIKMS передать параметр -m<width>x<height>x<refresh>, например:

/RD/1/DRIVERS/ATIKMS -m1280x800x60 -1

Здесь /RD/1/DRIVERS/ATIKMS — это путь до загрузчика (RD — RAM Disk).

При работе системы выбранный видеорежим можно посмотреть командой vmode и (теоретически) переключать вручную. Если «Колибри» запущена в виртуалке, то это окно останется пустым, а вот при чистой загрузке драйверы видео Intel можно добавить от i915 до Skylake включительно.

Удивительно, но в KolibriOS уместилась куча игр. Среди них есть логические и аркадные, пятнашки, змейка, танки (нет, не WoT) — целый «Игровой центр»! На «Колибри» портировали даже Doom и Quake.

Игровой центр

Еще из важного нашлась читалка FB2READ. Она корректно работает с кириллицей и имеет настройки отображения текста.

Самая легкая читалка FB2

Все пользовательские файлы рекомендую хранить на флешке, но подключать ее нужно обязательно через порт USB 2.0. Наша флешка USB 3.0 (в порте USB 2.0) объемом 16 Гбайт с файловой системой NTFS определилась сразу. Если нужно записывать файлы, то стоит подключить флешку с разделом FAT32.

Подключаем флешку

В дистрибутив «Колибри» входит три файловых менеджера, утилиты для просмотра изображений и документов, аудио- и видеоплееры и прочие пользовательские приложения. Однако основное внимание в ней уделено разработке на ассемблере.

Средства разработчика

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

Запуск программы прямо из TinyPad

Среди средств разработки есть компилятор Oberon-07/11 для i386 Windows, Linux и KolibriOS, а также низкоуровневые эмуляторы: E80 — эмулятор ZX Spectrum, FCE Ultra — один из лучших эмуляторов NES, DOSBox v.0.74 и другие. Все они были специально портированы на «Колибри».

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

Не пугайся, это скринсейвер!

Как появилась KolibriOS

Интересна и сама идея появления «Колибри». Это не очередной клон Linux, а совершенно уникальная разработка. Единственное, что роднит ее с Linux, — это открытый исходный код и финские корни.

Многие из авторов «Колибри» до этого работали в другом проекте — MenuetOS, из которой и выросла эта птичка. Они заметили, что у всех операционок есть общая проблема — дико раздутое и уже потому ненадежное ядро. Еще в начале нулевых об этом писал Брюс Шнайер в книге «Секреты и ложь. Безопасность данных в цифровом мире». Тогда ему казалось, что у популярных в то время ОС — всевозможных клонов UNIX, Windows NT 4.0 и следующей за ней Windows 2000 (NT 5.0) — все очень плохо с безопасностью именно из-за огромного ядра.

«Когда система UNIX была написана впервые, считалось обязательным помещение несущественных кодов за пределами ядра. <…> Все имеющиеся сейчас разновидности UNIX в той или иной степени страдают распуханием ядра: у них либо слишком много команд в ядре, либо имеются непонятные утилиты, запускающиеся в случае корневого доступа, либо что-то еще.
Windows NT устроена намного хуже. Эта операционная система может служить примером того, как полностью игнорируются исторические уроки безопасности. <…> Windows, похоже, придерживается мнения, что, поскольку то, что содержится в ядре, защищено по определению, следует просто побольше всего разместить прямо в ядре. Если разработчикам было непонятно, как обеспечить безопасность чего-либо, они просто запихивали это в ядро и считали его уже защищенным. <…>

<…> …Философия Windows NT в том, чтобы всегда отдавать предпочтение простому над безопасным — и в обращении, и в разработке», — писал Шнайер в 2000 году. Не сказать, что его книга стала откровением, но в ней были сформулированы те идеи, которые давно витали в воздухе.

Примерно тогда же группа программистов из Финляндии, Польши и стран бывшего СССР предприняла попытку создать принципиально новую операционку. Написать ее почти с нуля и сделать как можно компактнее — в идеале, чтобы она помещалась на дискету (флешек в те времена еще не было, и даже пишущий CD-привод казался диковиной).

Этой системой была MenuetOS. Идейным вдохновителем выступил Вилле Микаэль Турьянмаа. Когда-то он работал с MrOS — графической многозадачной оболочкой для DOS, со временем выросшей в отдельную операционку. Идеи MrOS легли в основу «Менуэта».

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

Позже состав команды разработчиков постоянно менялся. Очередные разногласия привели к тому, что в 2003 году отделившаяся группа решила сделать свой форк. Во время разработки он назывался MENUETOS RE, но на этапе релиза был переименован в Kolibri 0.1.0.0. Название было предложено Станиславом «VaStaNi» Валыйских. По замыслу оно должно отражать легковесность и скорость работы операционки. Официально «Колибри» вышла в мае 2004 года. Полноценным форком считается KolibriOS 0.50 — именно в ней более половины кода отличалось от MenuetOS.

Настоящее и будущее маленькой птички

Сейчас «Колибри» распространяется на условиях GPLv2, в то время как ее предшественница MenuetOS стала проприетарной в 64-битной версии.

Помимо базового дистрибутива KolibriOS, существует и расширенная версия. В ней доступна утилита установки драйверов DrvInst и другие дополнительные компоненты. DrvInst позволяет установить драйверы устройств, отсутствующие в образе IMG. Например, драйвер SATA с поддержкой AHCI, драйвер видео для процессоров Intel, видеокарт AMD и виртуалки VMware.

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

INFO

«Колибри» уже вошла в историю науки и киберпанка. Сотрудники Колумбийского университета и Нью-Йоркского геномного центра записали в ДНК операционную систему KolibriOS (PDF) вместе с другими данными общим объемом 2342 Кбайт.

Основное назначение KolibriOS осталось прежним — программирование на ассемблере в чистой среде безо всяких программных прослоек. Однако разработчик может писать свой код для KolibriOS и на языках высокого уровня (С/С++, Modula, Fort, Pascal). Это куда более простой способ создавать библиотеки, драйверы и программы.

WWW

MASM, TASM, FASM, NASM под Windows и Linux / Хабр

Часть I
Часть II
Часть III

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

MASM


Используется для создания драйверов под Windows.

По ссылке переходим на сайт и скачиваем пакет (masm32v11r.zip). После инсталляции программы на диске создается папка с нашим пакетом C:\masm32. Создадим программу prog11.asm, которая ничего не делает.
.586P
.model flat, stdcall 
_data segment 
_data ends
_text segment
start:
ret   
_text ends
end start

Произведём ассемблирование (трансляцию) файла prog11.asm, используя ассемблер с сайта masm32.


Ключ /coff используется здесь для трансляции 32-битных программ.
Линковка производится командой link /subsystem:windows prog11.obj (link /subsystem:console prog11.obj)

Как сказано в Википедии

MASM — один из немногих инструментов разработки Microsoft, для которых не было отдельных 16- и 32-битных версий.

Также ассемблер версии 6. можно взять на сайте Кипа Ирвина kipirvine.com/asm, автора книги «Язык ассемблера для процессоров Intel».

Кстати, вот ссылка на личный сайт Владислава Пирогова, автора книги “Ассемблер для Windows”.

MASM с сайта Microsoft

Далее скачаем MASM (версия 8.0) с сайта Microsoft по ссылке. Загруженный файл носит название «MASMsetup.exe». При запуске этого файла получаем сообщение -«Microsoft Visual C++ Express Edition 2005 required».

Открываем этот файл архиватором (например 7zip). Внутри видим файл setup.exe, извлекаем его, открываем архиватором. Внутри видим два файла vc_masm.msi,vc_masm1.cab. Извлекаем файл vc_masm1.cab, открываем архиватором. Внутри видим файл FL_ml_exe_____X86.3643236F_FC70_11D3_A536_0090278A1BB8. Переименовываем его в файл fl_ml.exe, далее, произведём ассемблирование файла prog11.asm, используя ассемблер fl_ml.exe.

MASM в Visual Studio

Также MASM можно найти в папке с Visual Studio (у меня VS 10) вот здесь: C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\ml.exe.

Для того, чтобы запустить на 32- или 64-разрядной системе и создавать программы, работающие как под 32-, так и под 64-разрядной Windows, подходит MASM32 (ml.exe, fl_ml.exe). Для того, чтобы работать на 32- и 64-разрядных системах и создавать программы, работающие под 64-разрядной Windows, но неработающие под 32-разрядной нужен ассемблер ml64.exe. Лежит в папке C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\amd64 и вот здесь — C:\Program Files\Microsoft Visual Studio 10.0\VC\bin\x86_amd64.

TASM


Программный пакет компании Borland, предназначенный для разработки программ на языке ассемблера для архитектуры x86. В настоящее время Borland прекратила распространение своего ассемблера.

Скачать можно, например, здесь. Инсталлятора нет, просто извлекаем программу. Вот исходник из книги Питера Абеля (рис. 3.2) «Язык Ассемблера для IBM PC и программирования».

stacksg segment para stack 'stack'
    db 12 dup ('stackseg')
stacksg ends
codesg segment para 'code'
begin proc far
 assume ss:stacksg,cs:codesg,ds:nothing
 push ds
 sub ax,ax
 push ax
 mov ax, 0123h
 add ax, 0025h
 mov bx,ax
 add bx,ax
 mov cx,bx
 sub cx,ax
 sub ax,ax
 nop
 ret
begin endp
codesg ends
 end begin

Выполним ассемблирование (трансляцию) файла abel32.asm.

Корректность работы программы можно проверить, произведя линковку (tlink.exe) объектного файла и запустив полученный файл в отладчике.

Как было сказано выше, MASM можно использовать для работы с 16-битными программами. Выполним ассемблирование (трансляцию) программы abel32.asm с помощью ассемблера MASM:

Ключ /coff здесь не используется.
Линковка производится файлом link16.exe

FASM


В статье Криса Касперски «Сравнение ассемблерных трансляторов» написано, что «FASM — неординарный и весьма самобытный, но увы, игрушечный ассемблер. Пригоден для мелких задач типа „hello, world“, вирусов, демок и прочих произведений хакерского творчества.»

Скачаем FASM с официального сайта. Инсталлятора нет, просто извлекаем программу. Откроем fasm editor — C:\fasm\fasmw.exe. В папке C:\fasm\EXAMPLES\HELLO есть файл HELLO.asm.

include 'win32ax.inc' 
.code
  start:
 invoke    MessageBox,HWND_DESKTOP,"Hi! I'm the example program!",invoke GetCommandLine,MB_OK
    invoke    ExitProcess,0
.end start

Откроем файл HELLO.asm из fasmw.exe. Изменим строку include ‘win32ax.inc’ на строку include ‘c:\fasm\INCLUDE\WIN32AX.INC’. Запускаем из меню Run → Run.

Вот ссылки на ресурсы, посвященные FASM:

→ FASM на Cyberforum’е
→ FASM на asmworld .com программы под Dos
→ Цикл статей «Ассемблер под Windows для чайников»
→ Сайт на narod’е

FASM в Linux

Для того, использовать FASM в Linux (у меня Ubuntu), скачаем соответствующий дистрибутив (fasm-1.71.60.tgz), распакуем его, в папке у нас будет бинарный файл fasm, копируем этот файл в /usr/local/bin для того, чтобы можно было запускать его из консоли, как любую другую команду.Выполним ассемблирование программы hello.asm из папки fasm/examples/elfexe/hello.asm.

Корректность работы программы можно проверить в отладчике.

Nasm


Nasm успешно конкурирует со стандартным в Linux- и многих других UNIX-системах ассемблером Gas.

Nasm в Linux можно установить его с помощью менеджера пакетов или из командной строки: в дистрибутиве Debian (Ubuntu) командой apt-get install nasm, в дистрибутивах Fedora, CentOS, RedHat командой yum install nasm.

Создадим программу, которая 5 раз выводит сообщение “Hello”. Пример взят из книги Андрея Викторовича Столярова “Программирование на языке ассемблера NASM для ОС UNIX”. Учебник, а также библиотека “stud_io.inc” есть на личном сайте автора.

%include "stud_io.inc"
global _start
section .text
_start: mov eax, 0
again:  PRINT "Hello"
PUTCHAR 10
inc eax
cmp eax, 5
jl again
FINISH

Выполним ассемблирование и линковку и запустим файл hello.asm.
$ nasm -f elf hello.asm
$ ld hello.o -o hello
$ ./hello

Для 64bit необходимо использовать команду nasm -f elf64 hello.asm

NASM для Windows

NASM для Windows можно установить, скачав соответствующий дистрибутив с соответствующего сайта.

Ассемблирование:
nasm -f bin имя_файла.asm -o имя_файла.com

Ссылки на ресурсы, посвященные Nasm:

→ Сайт А.В. Столярова
→ Сайт, на котором лежит электронный учебник (в архиве)
→ То же самое

AS


Стандартный ассемблер практически во всех разновидностях UNIX, в том числе Linux и BSD. Свободная версия этого ассемблера называется GAS (GNU assembler). Позволяет транслировать программы с помощью компилятора GCC.

Из учебников удалось найти только книгу на английском «Programming from the ground up». На русском удалось найти только одну главу из книги С. Зубкова «Assembler для DOS, Windows и UNIX».

Возьмем пример программы, которая ничего не делает, с сайта. Создадим программу gas.s

.section .text
   .globl _start
   _start:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:
$ as -o gas.o gas.s
$ ld -o gas gas.o
$ ./gas

Если в данной программе изменить _start на main, то можно выполнить ассемблирование (трансляцию) и линковку компилятором gcc.
.section .text
   .globl main
   main:
      movl  $1, %eax
      movl  $2, %ebx
      int   $0x80

Выполним ассемблирование (трансляцию), линковку и запуск программы:
$ gcc gas.s -o gas
$ ./gas

Выводы: если вы изучаете программирование под Windows, то вы можете остановить свой выбор на Masm; Tasm больше не поддерживается, но для обучения по старым классическим учебникам подойдёт.
Под Linux Gas подойдет тем, кто использует GCC, а тем, кому не нравится синтаксис Gas, подойдёт Nasm.

P.S. Следующие две части, в целом, посвящены обработке строки в цикле.
P.P.S. Little Man Computer — учебная модель компьютера с ограниченым набором ассемблерных инструкций рассматривается в этой статье.

Разработка на ассемблере в Linux / Хабр

Вообще программирование на ассемблере в Linux мало распространено и занимаются им, разве что, фанаты ассемблера. Сегодня мы и поговорим о программировании на ассемблере и инструментарий.Что нам понадобится:
  • FASM. Берем на flatassembler.net версию для Linux
  • ald. Берем на ald.sourceforge.net
  • shed. Берем на shed.sourceforge.net
  • ld. Есть в большинстве дистрибутивов

Собственно каждый для себя выбирает инструменты сам. Я выбрал для себя эти.
Установка FASM

После загрузки архива с офф. сайта распакуем его:

tar zxvf fasm-1.69.11.tgz

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

sudo ln -s /home/username/fasm/fasm /usr/local/bin

ald и shed устанавливаются не сложнее:

$ ./configure
$ make
# make install

В итоге у нас будет 3 полезных инструмента для программирования на ассемблере.

Системные вызовы

Как и большинство других операционных систем, Linux предоставляет т.н. API — набор полезных для программиста функций. В большинстве случаев вызов системной функции производится с помощью прерывания 80h. Следует отметить, что Linux используется fastcall-конвенция передачи параметров. Согласно ей параметры передаются через регистры (в windows, например, используется stdcall, где параметры передаются через стек). Номер вызываемой функции кладется в eax, а параметры в регистры:

Номер параметра / Регистр

1 / ebx
2 / ecx
3 / edx
4 / esi
5 / edi
6 / ebp

Как видите все не так сложно. Узнать номер системной функции, ее описание и параметры можно, хотя бы здесь. Возьмем, к примеру sys_exit. Как можно увидеть на той странице у нее есть один параметр — код возврата и она имеет порядковый номер 1. Таким образом мы можем вызвать ее следующим кодом:

mov eax, 1 ; 1 - номер системной функции
sub ebx, ebx ; Обнуляем регистр (можно было записать mov ebx, 0)
int 80h ; Вызываем прерывание 80h

Надеюсь, что все понятно.

Hello, World!

Ну что же. Писать мы ничего не будем, т.к. за нас все написано 🙂 В папке fasm/examples/elfexe есть файл hello.asm, в котором находится следующий код:

; fasm demonstration of writing simple ELF executable

format ELF executable 3
entry start

segment readable executable

start:

mov eax,4
mov ebx,1
mov ecx,msg
mov edx,msg_size
int 0x80

mov eax,1
xor ebx,ebx
int 0x80

segment readable writeable

msg db ‘Hello world!’,0xA
msg_size = $-msg

Как видите здесь вызываются 2 системных функции — sys_write (с порядковым номером 4) и sys_exit. sys_write принимает 3 параметра — дескриптор потока вывода (1 — stdout), указатель на строку и размер строки. Сам номер функции, как уже говорилось, мы должны положить в eax. Функцию sys_exit мы уже разобрали. Скомпилировать это чудо можно так: fasm hello.asm (но не обязательно, т.к. там же, где лежит исходник, есть и бинарник).

Посмотрим, что внутри

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

shed hello

Мы видим всю нашу программу, данные, elf-заголовок. Неплохо? Теперь мы посмотрим на нашу программу в отладчике. Наберем в консоли:

ald hello

Нас должна поприветствовать строка с предложением ввести команду. Список команд вы можете узнать, набрав help или получить помощь по отдельной команде, набрав help command. Дизассемблировать нашу программу можно командой disassemble (или ее алиас — «d«). Вы увидете дизассемблированный листинг вашей программы. Слева — адрес, справа — сама команда, а посередине — опкод команды.

Получить дамп можно командой dump (странно, но ее нет в выводе команды help).

Теперь попробуем поработать с командой next. Выполните ее и в ответ вам покажут значения регистров, установленные флаги, а так же адрес, опкод и дизассемблированную команду, которая должна выполниться следующей. Попробуйте выполнять команды и следите за изменением флагов и регистров. После вызова первого прерывания у вас на экране должна появиться надпись «Hello world!».

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

PS. Первая статья на хабре.

Полезные ссылки

asm.sourceforge.net
www.int80h.org

SASM – IDE для ассемблера / Хабр

Здравствуйте, уважаемые хабравчане!

Данным постом хочу представить сообществу проект, который время от времени писался мной последний год: SASM (SimpleASM) — IDE для разработки программ на языке ассемблера x86 и x86-64.

SASM — простая кроссплатформенная (доступна на Windows и Linux) среда разработки для языков ассемблера NASM, MASM, GAS, FASM с подсветкой синтаксиса и отладчиком. Программа работает «из коробки» и хорошо подойдет для начинающих изучение языка ассемблера. Основана на Qt. Распространяется по свободной лицензии GNU GPL v3.0.

Исходники лежат в репозитории на GitHub.
Бинарники можно скачать на сайте программы.

Под катом Вы найдете немножко истории и более подробное описание возможностей.

Откуда все пошло

На 1 курсе в моём университете проходил учебный курс «Архитектура и язык ассемблера», в котором мы изучали ассемблер NASM и сдавали задачи на нем в ejudge контестах. Привыкший к использованию IDE при программировании до этого, я был не очень рад компилить все в командной строке. Удобных на мой взгляд IDE для NASM не было. Универсальные решения типа Geany мне не очень нравились (хотя на вкус и цвет товарища нет — кто-то пользовался всем этим и был доволен). Да и хотелось уже сделать что-нибудь большое и заодно выучить C++.
Итак, было решено написать свою IDE для NASM, в первую очередь для себя и может быть однокурсников.

Опыта написания GUI у меня до этого не было. После недолгих раздумий было решено использовать Qt — хороший бесплатный фреймворк, заодно и кроссплатформенный. Сначала был написан просто текстовый редактор с простой подсветкой, логом построения и окнами ввода/вывода. Гордо называемая «IDE» программа умела собирать текст, который был в текстовом редакторе и запускать построенную программу.
Затем я, немного подучив регулярные выражения, сделал красивую подсветку. Прикрутил отладчик (GDB). Добавил вкладки и всякие простые фичи в текстовом редакторе типа поиска и комментирования куска кода. Постепенно допиливал программу до более-менее нормального вида, исправлял ошибки.

Весной этого года SASM был включен в вышеописанный учебный курс, и первокурсники уже пользовались им. Недавно добавил в программу поддержку и других ассемблеров, кроме NASM — MASM, FASM и GAS.

Возможности

Во-первых, это просто редактор кода с подсветкой, вкладками и возможностями построения и выполнения программы. Возможен запуск в отдельном окне.
В логе указывается информация о времени работы программы. Есть 2 формы для ввода и вывода. Как я уже говорил, программа изначально предназначалась для сдачи контестов. Две последние возможности очень удобны для этого. Если все-таки понадобиться сохранить exe’шник, это можно сделать в меню «Файл».

Отладчик

Один из самых сложных компонентов в программе — это отладчик. Возможностей у него не так много, но некий минимальный основной набор есть: он показывает текущую строку, делает шаг с заходом, без захода, продолжает выполнение/приостанавливает программу, можно ставить брейкпоинты, смотреть регистры и память. Также для тех кому базовых возможностей все же не хватает снизу окна реализована командная строка для ввода произвольных команд для GDB.

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

Библиотека макросов для NASM

В SASM включена библиотека макросов для ввода/вывода «io.inc», используемая в курсе «Архитектура и язык ассемблера» и немного переписанная для отладки и поддержки 64-битного режима. Она очень удобна на начальных этапах обучения — позволяет выводить данные, не задумываясь о соглашениях и правилах вызова функций.

Например, чтобы вывести число содержащееся в регистре EAX, достаточно написать

PRINT_DEC 4, eax ; 4 - количество байт

вместо

section .data
    format db "%d", 0
section .text
    push eax
    push format
    call printf
    add esp, 8

Команды, содержащиеся в «io.inc» можно найти в справке.

Опции

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

Также в параметрах доступен выбор ассемблера (NASM, MASM, GAS или FASM) и разрядности (x86 или x64). Эти опции влияют на выбор программ — ассемблера и компоновщика, и опций для них. Также под новый ассемблер подстраивается подсветка и начальный текст. Пути и опции сборки можно задать и вручную.

Дополнительно

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

На Windows все нужные для сборки программ компоненты уже включены в SASM. Программа работает «из коробки» — можно начинать программировать сразу же после запуска.
На Linux следует установить gcc, gdb и необходимый ассемблер.

Заключение

Больше информации о программе и исходники можно посмотреть по ссылкам выше. Качество кода в начале может быть не очень — только осваивал C++ и ООП, сразу на всякий случай прошу прощения.

Проект Open Source — так что, если вдруг кто-то хочет присоединиться и что-то поменять — Welcome!
Также буду рад отзывам, предложениям и сообщениям об ошибках. И конечно разумной критике, куда без нее.

Простая программа на ассемблере x86: Решето Эратосфена / Хабр

Вступительное слово

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

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

До ее написания я сформулировал такие требования к будущей программе:

  • Моя программа не должна быть программой под DOS. Слишком много примеров ориентировано на нее в связи с простым API. Моя программа обязательно должна была запускаться на современных ОС.
  • Программа должна использовать кучу – получать в свое распоряжение динамически распределяемую память.
  • Чтобы не быть слишком сложной, программа должна работать с целыми беззнаковыми числами без использования переносов.

Задачей для своей программы я выбрал поиск простых чисел с помощью Решета Эратосфена. В качестве ассемблера я выбрал nasm.

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

Итак, посмотрим, что получилось.

С чего начать?

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

Так же встает вопрос, каким образом на таком низком уровне реализуется обмен данными между внутренним миром программы и внешней средой. Тут на сцену выходит API операционной системы. В DOS, как уже было упомянуто, интерфейс был достаточно простой. К примеру, программа «Hello, world» выглядела так:

SECTION .text
    org 0x100

    mov ah, 0x9
    mov dx, hello
    int 0x21
    
    mov ax, 0x4c00
    int 0x21

SECTION .data
    hello: db "Hello, world!", 0xD, 0xA, '$'

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

%include "win32n.inc"

extern MessageBoxA
import MessageBoxA user32.dll
extern ExitProcess
import ExitProcess kernel32.dll

SECTION code use32 class=code
    ..start:

    push UINT MB_OK
    push LPCTSTR window_title
    push LPCTSTR banner
    push HWND NULL
    call [MessageBoxA]

    push UINT NULL
    call [ExitProcess]

SECTION data use32 class=data
    banner: db "Hello, world!", 0xD, 0xA, 0
    window_title: db "Hello", 0

Здесь используется файл win32n.inc, где определены макросы, сокращающие код для работы с Win32 API.

Я решил не использовать напрямую API ОС и выбрал путь использования функций из библиотеки Си. Так же это открыло возможность компиляции программы в Linux (и, скорее всего, в других ОС) – не слишком большое и нужное этой программе достижение, но приятное достижение.

Вызов подпрограмм

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

Подпрограммы представляют собой метку, по которой располагается код. Заканчивается подпрограмма инструкцией ret. К примеру, вот такая подпрограмма в DOS выводит в консоль строку «Hello, world»:

print_hello:
    mov ah, 0x9
    mov dx, hello
    int 0x21
    ret

Для ее вызова нужно было бы использовать инструкцию call:

call print_hello

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

push hello
call _printf
add esp, 4

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

При входе в подпрограмму необходимо создать новый стековый кадр. Делается это следующим образом:

print_hello:
    push ebp ;сохраняем указатель начала стекового кадра на стеке
    mov ebp, esp ;теперь началом кадра является вершина предыдущего

Соответственно, перед выходом нужно восстановить прежнее состояние стека:

    mov esp, ebp
    pop ebp
    ret

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

print_hello:
    push ebp
    mov ebp, esp
    sub esp, 8 ;опускаем указатель вершины стека на 8 байт, чтобы выделить память

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

print_hello:
    enter 8, 0 ;создать новый кадр, выделить 8 байт для локальных переменных

    leave ;восстановить стек
    ret

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

Непосредственно программа

Проект содержит такие файлы:
  • main.asm – главный файл,
  • functions.asm – подпрограммы,
  • string_constants.asm – определения строковых констант,
  • Makefile – сценарий сборки

Рассмотрим код основного файла:main.asm
%define SUCCESS 0
%define MIN_MAX_NUMBER 3
%define MAX_MAX_NUMBER 4294967294

global _main
extern _printf
extern _scanf
extern _malloc
extern _free

SECTION .text
_main:
	enter 0, 0
	
	;ввод максимального числа
	call input_max_number
	cmp edx, SUCCESS
	jne .custom_exit
	mov [max_number], eax
	
	;выделяем память для массива флагов
	mov eax, [max_number]
	call allocate_flags_memory
	cmp edx, SUCCESS
	jne .custom_exit
	mov [primes_pointer], eax
	
	;отсеять составные числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call find_primes_with_eratosthenes_sieve
	
	;вывести числа
	mov eax, [primes_pointer]
	mov ebx, [max_number]
	call print_primes
	
	;освободить память от массива флагов
	mov eax, [primes_pointer]
	call free_flags_memory
	
	;выход
	.success:
		push str_exit_success
		call _printf
		jmp .return
			
	.custom_exit:
		push edx
		call _printf
		
	.return:
		mov eax, SUCCESS
		leave
		ret
	
	%include "functions.asm"

SECTION .data
	max_number: dd 0
	primes_pointer: dd 0
	
	%include "string_constants.asm"


Видно, что программа поделена по смыслу на 5 блоков, оформленных в виде подпрограмм:
  1. input_max_number — с помощью консоли запрашивает у пользователя максимальное число, до которого производится поиск простых; во избежание ошибок значение ограничено константами MIN_MAX_NUMBER и MAX_MAX_NUMBER
  2. allocate_flags_memory — запросить у ОС выделение памяти для массива пометок чисел (простое/составное) в куче; в случае успеха возвращает указатель на выделенную память через регистр eax
  3. find_primes_with_eratosthenes_sieve — отсеять составные числа с помощью классического решета Эратосфена;
  4. print_primes — вывести в консоль список простых чисел;
  5. free_flags_memory — освободить память, выделенную для флагов

Для функций было условлено такое правило: значение возвращается через регистр eax, регистр edx содержит статус. В случае успеха он содержит значение SUCCESS, то есть, 0, в случае неудачи — адрес строки с сообщением об ошибке, которое будет выведено пользователю.

Файл string_constants.asm содержит определение строковых переменных, значения которых, как намекает название файла, менять не предполагается. Только ради этих переменных было сделано исключение к правилу «не использовать глобальные переменные». Я так и не нашел более удобного способа доставлять строковые константы функциям ввода-вывода – подумывал даже записывать на стек непосредственно перед вызовами функций, но решил, что эта идея куда хуже идеи с глобальными переменными.

string_constants.asm
;подписи ввода-вывода, форматы
str_max_number_label: db "Max number (>=3): ", 0
str_max_number_input_format: db "%u", 0
str_max_number_output_format: db "Using max number %u", 0xD, 0xA, 0

str_print_primes_label: db "Primes:", 0xD, 0xA, 0
str_prime: db "%u", 0x9, 0
str_cr_lf: db 0xD, 0xA, 0
	
;сообщения выхода
str_exit_success: db "Success!", 0xD, 0xA, 0
str_error_max_num_too_little: db "Max number is too little!", 0xD, 0xA, 0
str_error_max_num_too_big: db "Max number is too big!", 0xD, 0xA, 0
str_error_malloc_failed: db "Can't allocate memory!", 0xD, 0xA, 0


Для сборки применяется такой сценарий:Makefile
ifdef SystemRoot
   format = win32
   rm = del
   ext = .exe
else
   format = elf
   rm = rm -f
   ext = 
endif

all: primes.o
	gcc primes.o -o primes$(ext)
	$(rm) primes.o

primes.o:
	nasm -f $(format) main.asm -o primes.o

Подпрограммы (функции)

input_max_number

Код подпрограммы
; Ввести максимальное число
; Результат: EAX - максимальное число
input_max_number:	
	;создать стек-фрейм,
	;4 байта для локальных переменных
	enter 4, 1

	;показываем подпись
	push str_max_number_label ;см. string_constants.asm
	call _printf
	add esp, 4

	;вызываем scanf
	mov eax, ebp
	sub eax, 4
	
	push eax
	push str_max_number_input_format ;см. string_constants.asm
	call _scanf
	add esp, 8
	
	mov eax, [ebp-4]

	;проверка
	cmp eax, MIN_MAX_NUMBER
	jb .number_too_little
	cmp eax, MAX_MAX_NUMBER
	ja .number_too_big
	jmp .success

	;выход
	.number_too_little:
		mov edx, str_error_max_num_too_little ;см. string_constants.asm
		jmp .return	
		
	.number_too_big:
		mov edx, str_error_max_num_too_big ;см. string_constants.asm
		jmp .return	

	.success:
		push eax
		push str_max_number_output_format ;см. string_constants.asm
		call _printf
		add esp, 4
		pop eax
		mov edx, SUCCESS
	
	.return:
		leave
		ret


Подпрограмма призвана ввести в программу максимальное число, до которого будет производиться поиск простых. Ключевым моментов тут является вызов функции scanf из библиотеки Си:
        mov eax, ebp
        sub eax, 4
	
        push eax
        push str_max_number_input_format ;см. string_constants.asm
        call _scanf
        add esp, 8
	
        mov eax, [ebp-4]

Таким образом, сначала в eax записывается адрес памяти на 4 байта ниже указателя базы стека. Это память, выделенная для локальных нужд подпрограммы. Указатель на эту память передается функции scanf как цель для записи данных, введенных с клавиатуры.

После вызова функции, в eax из памяти перемещается введенное значение.

allocate_flags_memory и free_flags_memory

Код подпрограмм
; Выделить память для массива флагов
; Аргумент: EAX - максимальное число
; Результат: EAX - указатель на память
allocate_flags_memory:
	enter 8, 1

	;выделить EAX+1 байт
	inc eax
	mov [ebp-4], eax
	
	push eax
	call _malloc
	add esp, 4
	
	;проверка
	cmp eax, 0
	je .fail
	mov [ebp-8], eax
	
	;инициализация
	mov byte [eax], 0
	
	cld
	mov edi, eax
	inc edi
	mov edx, [ebp-4]
	add edx, eax
	
	mov al, 1
	.write_true:
		stosb
		cmp edi, edx
		jb .write_true
	
	;выход
	mov eax, [ebp-8]
	jmp .success
	
	.fail:
		mov edx, str_error_malloc_failed ;см. string_constants.asm
		jmp .return
	
	.success:
		mov edx, SUCCESS
			
	.return:
		leave
		ret

; Освободить память от массива флагов
; Аргумент: EAX - указатель на память
free_flags_memory:
	enter 0, 1
	
	push eax
	call _free
	add esp, 4
	
	leave
	ret


Ключевыми местами этих подпрограмм являются вызовы функций malloc и free из библиотеки Си.

malloc в случае удачи возвращает через регистр eax адрес выделенной памяти, в случае неудачи этот регистр содержит 0. Это самое узкое место программы касательно максимального числа. 32 бит вполне достаточно для поиска простых чисел до 4 294 967 295, но выделить разом столько памяти не получится.

find_primes_with_eratosthenes_sieve

Код подпрограммы
;Найти простые числа с помощью решета Эратосфена
;Аргументы: EAX - указатель на массив флагов, EBX - максимальное число	
find_primes_with_eratosthenes_sieve:
	enter 8, 1
	mov [ebp-4], eax
		
	add eax, ebx
	inc eax
	mov [ebp-8], eax
	
	;вычеркиваем составные числа
	cld
	mov edx, 2 ;p = 2
	mov ecx, 2 ;множитель с = 2
	.strike_out_cycle:
		;x = c*p
		mov eax, edx
		push edx
		mul ecx
		pop edx
		
		cmp eax, ebx
		jbe .strike_out_number
		jmp .increase_p
		
		.strike_out_number:
			mov edi, [ebp-4]
			add edi, eax
			mov byte [edi], 0
			inc ecx ;c = c + 1
			jmp .strike_out_cycle
			
		.increase_p:
			mov esi, [ebp-4]
			add esi, edx
			inc esi
			
			mov ecx, edx
			inc ecx
			.check_current_number:
				mov eax, ecx
				mul eax
				cmp eax, ebx
				ja .return
			
				lodsb
				inc ecx
				cmp al, 0
				jne .new_p_found
				jmp .check_current_number
			
				.new_p_found:
					mov edx, ecx
					dec edx
					mov ecx, 2
					jmp .strike_out_cycle			
	
	.return:
		leave
		ret

Подпрограмма реализует классический алгоритм для вычеркивания составных чисел, решето Эратосфена, на языке ассемблера x86. Приятна тем, что не использует вызовы внешних функций и не требует обработки ошибок 🙂

print_primes

Код подпрограммы
; Вывести простые числа
; Параметры: EAX - указатель на массив флагов, EBX - максимальное число
print_primes:
	enter 12, 1
	mov [ebp-4], eax
	mov [ebp-8], ebx
	
	push str_print_primes_label
	call _printf
	add esp, 4
	
	cld
	mov esi, [ebp-4]
	mov edx, esi
	add edx, [ebp-8]
	inc edx
	
	mov [ebp-12], edx
	mov ecx, 0
	.print_cycle:
		lodsb
		cmp al, 0
		jne .print
		jmp .check_finish
		.print:
			push esi
			push ecx
			push str_prime ;см. string_constants.asm
			call _printf
			add esp, 4
			pop ecx
			pop esi
			mov edx, [ebp-12]
		.check_finish:
			inc ecx
			cmp esi, edx
			jb .print_cycle
			
	push str_cr_lf
	call _printf
	add esp, 4
			
	leave
	ret


Подпрограмма выводит в консоль простые числа. Ключевым моментом тут является вызов функции printf из библиотеки Си.
Заключение

Что ж, программа отвечает всем сформулированным требованиям и, кажется, проста для понимания. Хочется надеяться, кому-нибудь ее разбор поможет вникнуть в программирование на низком уровне и он получит от него такое же удовольствие, какое получил я.

Так же привожу полные исходники программы.

Могу так же привести интересный факт. Поскольку с детства нас учили, что программы на языке ассемблера выполняются быстрее, я решил сравнить скорость выполнения этой программы со скоростью программы на C++, которую я писал когда-то и которая искала простые числа с помощью Решета Аткина. Программа на С++, скомпилированная в Visual Studio с /O2 выполняла поиск до числа 230 примерно за 25 секунд на моей машине. Программа же на ассемблере показала 15 секунд с Решетом Эратосфена.

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

Полезные ссылки

  1. Список ресурсов для изучения ассемблера
  2. Организация памяти
  3. Решето Эратосфена
  4. Решето Аткина
  5. Стек
  6. Стековый кадр

Дизассемблер своими руками / Хабр

     Знание структуры машинных команд уже много лет не является обязательным, для того, чтобы человек мог назвать себя программистом. Естественно так было не всегда. До появления первых ассемблеров программирование осуществлялось непосредственно в машинном коде. Каторжная работа, сопряженная с большим количеством ошибок. Современные ассемблеры позволяют (в разумной степени) абстрагироваться от железа, метода кодирования команд. Что уж говорить о компиляторах высокоуровневых языков. Они поражают сложностью своей реализации и той простотой, с которой программисту позволяется преобразовывать исходный код в последовательность машинных команд (причем преобразовывать, в достаточной степени, оптимально). От программиста требуется лишь знание любимого языка/ IDE. Знание того, во что преобразует компилятор исходный листинг вовсе не обязательно.
Тем же, кому интересно взглянуть на краткое описание структуры кодирования машинных команд, пример реализации и исходный код дизассемблера для x86 архитектуры, добро пожаловать.


     Создание дизассемблера для x86 архитектуры является, хотя задачей и не особо сложной, но все, же довольно специфичной. От программиста требуются определенного рода знания – знания того, как микропроцессор распознает последовательность “байтиков” в машинном коде. Далеко не в каждом вузе можно получить такие знания в объеме достаточном для написания полнофункционального современного дизассемблера – приходится искать самому (как правило, на английском языке). Данный пост не претендует на полноту освещение проблемы создания дизассемблера, в нем лишь кратко рассказывается то, как был написан дизассемблер для x86 архитектуры, 32-разрядного режима исполнения команд. Так же хотелось бы отметить вероятность возможных неточностей при переводе некоторых понятий из официальной спецификации.

     Структура команд для intel x86

Структура команды следующая:
• Опциональные префиксы (каждый префикс имеет размер 1 байт)
• Обязательный опкод команды (1 или 2 байта)
• Mod_R/M – байтик, определяющий структуру операндов команды — опциональный.
• Опциональные байты, занимаемые операндами команды (иногда разделено как один байт поля SIB[Scale, Index, Base], смещения и непосредственного значения).

Префиксы

     Существуют следующие префиксы:
Первые шесть изменяют сегментный регистр, используемый командой при обращении к ячейке памяти.
• 0x26 – префикс замены сегмента ES
• 0x2E – префикс замены сегмента CS
• 0x36 – префикс замены сегмента SS
• 0x3E – префикс замены сегмента DS
• 0x64 – префикс замены сегмента FS
• 0x65 – префикс замены сегмента GS

• 0x0F – префикс дополнительных команд (иногда его не считают за настоящий префикс – в этом случае считается, что опкод команды состоит из двух байт, первый из которых 0x0F)

• 0x66 – префикс переопределения размера операнда (к примеру, вместо регистра eax будет использоваться ax)
• 0x67 – префикс переопределения размера адреса (см ниже)
• 0x9B – префикс ожидания (WAIT)
• 0xF0 – префикс блокировки (LOCK с его помощью реализуется синхронизация многопоточных приложений)
• 0xF2 – префикс повторенья команды REPNZ – работа с последовательностями байт (строками)
• 0xF3 – префикс повторенья команды REP – работа с последовательностями байт (строками)

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

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

Байт Mod_R/M состоит из следующих полей:

• Mod – первые два бита (значение от 0 до 3)
• R/M – следующие три бита (значение от 0 до 7)
• Value of ModR/M – следующие три бита (значение от 0 до 7)

     Реализация:

Для написания дизассемблера мы будем использовать следующую страничку: http://ref.x86asm.net/geek32.html.

     Мы видим несколько таблиц. В сущности, только эти таблицы и описание их полей нам и понадобятся, для написания дизассемблера. Конечно, дополнительно требуется способность к логическому рассуждению и свободное время.
     В первой таблице представлен список машинных команд, не содержащих префикс 0x0F. Во второй список команд содержащих этот префикс (большинство этих команд появились в микропроцессорах семейства “Pentium with MMX” или более поздних).
     Следующие три таблицы позволяют преобразовать байт Mod_R/M в последовательность операндов команды для 32-битного режима кодировки команд. Причем каждая последующая из этих трех таблиц уточняет разбор Mod_R/M байта частных случаев предыдущей таблицы.
     Последняя таблица позволяет преобразовать байт Mod_R/M в последовательность операндов команды для 16-битного режима кодировки команд. По умолчанию считается, что команда кодируется в 32-битном режиме. Для смены режима кодировки используется префикс переопределения размера адреса (0x67).

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

Сам алгоритм дизассемблирования достаточно прост:

• Собирается список префиксов, используемых в текущей машинной инструкции
• Ищется в одной из двух таблиц соответствующее поле в зависимости от опкода, префиксов и поколения (модели) целевого (искомого) микропроцессора.
• Найденная нами запись характеризуется списком полей такими как поколение (модель) микропроцессора, с которого появилась поддержка данной команды или, например, список флагов, которые данная команда может изменить. Нас же, в основном, интересуют лишь мнемоника (название) команды и список операндов. Проанализировав все операнды найденной и поля байта Mod_R/M, мы сможем узнать текстовое представление и длину команды.

     Количество операндов может колебаться от нуля до трех. Исходные таблицы содержат более сотни типов операндов. Некоторые операнды дублируются – у них различные названия, но последовательность действий обработки Mod_R/M байта (и возможно последующих байтов) у них одинакова.

     Для просмотра примера обработки различных операндов и примера дизассемблирования простейшей функции “Hello world” можно скачать исходный код дизассемблера для компилятора C++ Builder 6.

PS:
Не факт, что кому-то из прочитавших этот пост, когда-либо понадобится информация, почерпнутая из него (дизассемблеры пишут единицы), но, в любом случае этот дизассемблер тестировался и даже входит в состав достаточно большего коммерческого протектора, исходники открыты и распространяются свободно )

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

Навигация

(C) 2017 Майк Сондерс и разработчики MikeOS

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

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



Требования

Необходим предварительный опыт программирования. Если вы написали код на языке высокого уровня, например PHP или Java, это нормально, но на самом деле вам нужно знать язык нижнего уровня, такой как C, особенно на тему памяти и указателей.

Для этого руководства мы используем Linux.Сейчас установить Linux очень просто; возьмите Ubuntu и установите это в VirtualBox или VMware, если вы не хотите выполнять двойную загрузку. Когда ты в Ubuntu получите все инструменты, необходимые для выполнения этого руководства, введя это в окне терминала:

 sudo apt-get install build-essential qemu nasm 

Это дает вам набор инструментов разработки (компилятор и т. Д.), QEMU PC эмулятор и ассемблер NASM, который преобразует язык ассемблера в исполняемые файлы необработанного машинного кода.



Праймер для ПК

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

Когда ПК включен, он начинает выполнение BIOS (базовая система ввода / вывода), которая по сути является мини-ОС встроен в систему. Он выполняет несколько тестов оборудования (например, проверки памяти) и обычно выводит графику (например, Dell логотип) или диагностический текст на экране. Затем, когда это будет сделано, он начнет загружать вашу операционную систему с любого носителя. могу найти.Многие ПК переходят к жесткому диску и начинают выполнять код, который они находят в основной загрузочной записи (MBR), 512-байтовой секции. в начале жесткого диска; некоторые пытаются найти исполняемый код на дискете (загрузочном секторе) или CD-ROM.

Все зависит от порядка загрузки — обычно вы можете указать его на экране параметров BIOS. BIOS загружает 512 байт с выбранного носителя в свою память и начинает его выполнение. Это загрузчик, небольшая программа, которая затем загружает основное ядро ​​ОС или большую загрузочную программу (например, GRUB / LILO для систем Linux).Это 512 байт Загрузчик имеет два специальных номера в конце, чтобы сообщить ОС, что это загрузочный сектор — мы рассмотрим это позже.

Обратите внимание, что у ПК есть интересная функция для загрузки. Исторически сложилось так, что на большинстве ПК был дисковод для гибких дисков, поэтому BIOS был настроен для загрузки с этого устройства. Однако сегодня на многих ПК нет дисковода для гибких дисков — только CD-ROM, поэтому разработан для этого. Когда вы загружаетесь с CD-ROM, может имитировать дискету ; BIOS читает CD-ROM привод, загружает блок данных и выполняет его, как если бы это была дискета.Это невероятно полезно для нас, разработчиков ОС, поскольку мы можем делать версии нашей ОС на гибких дисках, но при этом загружать ее только с компакт-дисков. (Дискеты действительно легко работать с файловыми системами CD-ROM гораздо сложнее.)

Итак, напомним, процесс загрузки:

  1. Включение: компьютер запускается и начинает выполнение кода BIOS.
  2. BIOS ищет различные носители, такие как гибкий диск или жесткий диск.
  3. BIOS загружает 512-байтовый загрузочный сектор с указанного носителя и начинает его выполнение.
  4. Эти 512 байт затем используются для загрузки самой ОС или более сложного загрузчика.

Для MikeOS у нас есть 512-байтовый загрузчик, который мы записываем в файл образа гибкого диска (виртуальную дискету). Тогда мы можем вставьте этот образ дискеты в компакт-диск для компьютеров, на которых есть только приводы компакт-дисков. В любом случае BIOS загружает его, как если бы он был включен. дискету и начинает ее выполнение. У нас есть контроль над системой!



Учебник по языку ассемблера

Большинство современных операционных систем написано на C / C ++.Это очень полезно, когда переносимость и ремонтопригодность кода имеет решающее значение, но это добавляет дополнительный уровень сложности процессу. Для вашей самой первой ОС лучше придерживаться с языком ассемблера, который используется в MikeOS. Он более подробный и непереносимый, но вам не нужно беспокоиться о компиляторах и линкеры. Кроме того, вам потребуется немного сборки, чтобы запустить любую ОС.

Язык ассемблера (или в просторечии «asm») — это текстовый способ представления инструкций, которые выполняет ЦП.За Например, инструкция по перемещению некоторой памяти в ЦП может быть 11001001 01101110 — но это вряд ли памятный! Таким образом, сборка предоставляет мнемонику, заменяющую эти инструкции, например, mov ax, 30 . Они напрямую соотносятся с инструкциями машинного кода ЦП, но без бессмысленных двоичных чисел.

Как и большинство языков программирования, ассемблер представляет собой список инструкций, выполняемых по порядку. Вы можете прыгать между в разных местах и ​​настраивать подпрограммы / функции, но это намного проще, чем C # и его друзья.Вы не можете просто распечатать «Привет, мир» экрану — ЦП не имеет представления о том, что такое экран! Вместо этого вы работаете с памятью, манипулируя куски ОЗУ, выполняя над ними арифметические операции и помещая результаты в нужные места. Страшно звучит? Это немного чуждо сначала, но это не трудно понять.

На уровне языка ассемблера нет такой вещи, как переменные в понимании языка высокого уровня. Что у тебя есть, однако это набор из регистров , которые являются хранилищами памяти процессора.Вы можете помещать числа в эти регистры и произвести по ним расчеты. В 16-битном режиме эти регистры могут содержать числа от 0 до 65535. Вот список основные регистры на типичном процессоре x86:

AX, BX, CX, DX Регистры общего назначения для хранения используемых вами чисел. Например, вы можете использовать AX для хранения символа которая была нажата на клавиатуре, при этом CX действует как счетчик в цикле. (Примечание: эти 16-битные регистры могут быть разделенным на 8-битные регистры, такие как AH / AL, BH / BL и т. д.)
SI, DI Регистры индекса данных источника и назначения. Они указывают на места в памяти для извлечения и хранения данных.
СП Указатель стека (объяснение чуть ниже).
IP (иногда CP) Указатель инструкции / кода. Он содержит место в памяти выполняемой инструкции. Когда инструкция завершена, она увеличивается и переходит к следующей инструкции.Вы можете изменить содержимое этого регистра, чтобы перемещаться по вашему коду.

Таким образом, вы можете использовать эти регистры для хранения чисел во время работы — немного похоже на переменные, но их много более фиксированные по размеру и назначению. Есть несколько других, в частности сегментных регистров . Из-за В старых ПК память обрабатывалась блоками по 64 КБ, называемыми сегментами. Это действительно запутанная тема, но к счастью, вам не нужно об этом беспокоиться — на данный момент ваша ОС в любом случае будет меньше килобайта! В MikeOS мы ограничиваем себя одним сегментом размером 64 КБ, чтобы нам не пришлось возиться с регистрами сегментов.

Стек — это область вашей основной RAM, используемая для хранения временной информации. Это называется стек, потому что числа складываются одно поверх другого. Представьте себе трубку Принглса: если вы поставите карты, iPod Shuffle и пивного коврика, вытащите их в обратном порядке (пивовар, затем iPod и, наконец, игральная карта). То же самое и с числами: если вы поместите числа 5, 7 и 15 в стек, вы сначала вытолкните как 15, затем 7 и, наконец, 5.В сборке вы можете нажимать регистры в стек и вытащить их позже — это полезно, когда вы хотите временно сохранить значение регистра, пока вы используйте этот регистр для чего-нибудь еще.

ПК память можно рассматривать как линейную линию ячеек в диапазоне от байта 0 до всего, что у вас есть установлен (миллионы байт на современных машинах). Например, в байтах с номером 53 634 246 в вашей оперативной памяти у вас может быть код веб-браузера для просмотра этого документа. Но в то время как мы, люди, считаем в степени 10 (10, 100, 1000 и т. Д.- десятичный), компьютерам лучше использовать степень двойки (потому что они основаны на двоичной системе). Итак, мы используем в шестнадцатеричном формате , который равен по основанию 16 , как способ представления чисел. См. Эту диаграмму, чтобы понять:

Десятичный 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
Шестнадцатеричный 0 1 2 3 4 5 6 7 8 9 А В С D E F 10 11 12 13 14

Как видите, в то время как наша обычная десятичная система использует 0 — 9, шестнадцатеричная использует 0 — F при подсчете.Это немного странно сначала, но вы научитесь. В программировании на ассемблере мы определяем шестнадцатеричные (шестнадцатеричные) числа с помощью тегов ‘h’ в конец — так что 0Ah шестнадцатеричный для числа 10 . (Вы также может обозначать шестнадцатеричное в ассемблере, добавляя к числу префикс 0x — например, 0x0A.)

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

mov Копирует память из одного места или регистра в другое. Например, mov ax, 30 помещает число 30 в регистр AX. Используя квадратные скобки, вы можете получить число в той ячейке памяти, на которую указывает регистр. Например, если BX содержит 80, тогда mov ax, [bx] означает «получить число в ячейке памяти 80 и поместить это в AX «. Вы также можете перемещать числа между регистрами: mov bx, cx .
добавить / добавить Добавляет число в регистр. добавить топор, FFh добавляет FF в шестнадцатеричном формате (255 в нашем обычном десятичном) к регистр AX. Таким же образом можно использовать sub : sub dx, 50 .
cmp Сравнивает регистр с числом. cmp cx, 12 сравнивает регистр CX с числом 12. Это затем обновляет специальный регистр на CPU под названием FLAGS — специальный регистр, содержащий информацию по поводу последней операции. В этом случае, если число 12 больше, чем значение в CX, оно генерирует отрицательное результат, и отмечает, что отрицательный в регистре FLAGS.Мы можем использовать это в следующих инструкциях …
jmp / jg / jl … Перейти к другой части кода. jmp label переходит (GOTOs) к части нашего исходного кода где у нас метка: написано . Но это еще не все — можно переходить условно, в зависимости от процессора. флаги, установленные в предыдущей команде. Например, если инструкция cmp определила, что регистр имеет меньшее значение, чем то, с которым оно сравнивалось, вы можете действовать с помощью jl label (jump если меньше — чем на этикетке).Точно так же jge label переходит к ‘label’ в коде, если значение в cmp было больше или равно сравниваемому номеру.
внутр Прервать выполнение программы и перейти в указанное место в памяти. Операционные системы настроили прерывания которые аналогичны подпрограммам в языках высокого уровня. Например, в MS-DOS прерывание 21h обеспечивает DOS сервисы (например, открытие файла). Обычно вы помещаете значение в регистр AX, затем вызываете прерывание и ждете результат (тоже передан обратно в реестр).Когда вы пишете ОС с нуля, вы можете вызвать BIOS с int 10h, int 13h, int 14h или int 16h для выполнения таких задач, как печать строк, чтение секторов с дискеты и т. д.

Давайте рассмотрим некоторые из этих инструкций более подробно. Рассмотрим следующий фрагмент кода:

 mov bx, 1000h
mov ax, [bx]
cmp топор, 50
этикетка jge
...

этикетка:
мов топор, 10
 

В первой инструкции мы перемещаем число 1000h в регистр BX.Затем во второй инструкции мы сохраняем в AX все, что находится в ячейке памяти, на которую указывает BX. Вот что означает [bx] : если бы мы только что сделали mov ax, bx он просто скопирует число 1000h в регистр AX. Но используя квадратные скобки, мы говоря: не просто копируйте содержимое BX в AX, а копируйте содержимое адреса памяти, на который указывает BX. Данный что BX содержит 1000h, эта инструкция говорит: найдите то, что находится в ячейке памяти 1000h, и поместите это в AX.

Итак, если байт памяти в ячейке 1000h содержит 37, то это число 37 будет помещено в регистр AX через наша вторая инструкция. Затем мы используем cmp для сравнения числа в AX с числом 50 (десятичное номер 50 — мы не добавляли суффикс «h»). Следующая инструкция jge действует при сравнении cmp , который установил регистр FLAGS, как описано ранее. На этикетке jge написано: если результат из предыдущего сравнение больше или равно, перейдите к части кода, обозначенной меткой : .Итак, если число в AX больше или равно 50, выполнение переходит к метке :. В противном случае выполнение продолжается на этапе «…».

И последнее: вы можете вставлять данные в программу с помощью директивы db (define byte). Например, это определяет серию байтов с нулем в конце, представляющую строку:

 mylabel: db 'Сообщение здесь', 0
 

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

 foo: db 0
 

Теперь foo: указывает на один байт в коде, который в случае MikeOS будет доступен для записи. поскольку ОС полностью копируется в ОЗУ. Итак, у вас могла быть эта инструкция:

 mov byte al, [foo]
 

Перемещает байт, на который указывает foo , в регистр AL.

Итак, это основы ассемблера для ПК x86, и этого достаточно, чтобы вы начали.



Ваша первая ОС

Теперь вы готовы написать свое первое ядро ​​операционной системы! Конечно, это будет крайне скудно, просто 512-байтовый загрузочный сектор, как описано ранее, но это отправная точка для дальнейшего расширения. Вставьте следующий код в файл с именем myfirst.asm и сохраните его в своем домашнем каталоге — это исходный код для вашего первого ОПЕРАЦИОННЫЕ СИСТЕМЫ.

 БИТЫ 16

Начало:
mov ax, 07C0h; Установите пространство стека 4K после этого загрузчика
добавить топор, 288; (4096 + 512) / 16 байт на параграф
mov ss, топор
mov sp, 4096

mov ax, 07C0h; Установите сегмент данных туда, где мы загружены
mov ds, топор


mov si, text_string; Поместите позицию строки в SI
вызов print_string; Вызовите нашу процедуру печати строк

jmp $; Прыгай сюда - бесконечный цикл!


text_string db 'Это моя крутая новая ОС!', 0


print_string:; Процедура: вывод строки в СИ на экран
mov ah, 0Eh; Функция int 10h 'print char'

.повторение:
lodsb; Получить символ из строки
cmp al, 0
je .done; Если char равен нулю, конец строки
int 10h; В противном случае распечатайте это
jmp .repeat

.сделанный:
Ret


умножить на 510 - ($ - $$) db 0; Заполните остаток загрузочного сектора нулями
dw 0xAA55; Стандартная подпись загрузки ПК
 

Давайте рассмотрим это. Строка BITS 16 не является инструкцией процессора x86; он просто сообщает NASM ассемблер, что мы работаем в 16-битном режиме. Затем NASM может преобразовать следующие инструкции в необработанный двоичный файл x86.Затем у нас есть метка start: , которая не является строго необходимой, поскольку выполнение начинается прямо в начале файл в любом случае, но это хороший маркер. С этого момента обратите внимание, что символ точки с запятой (;) используется для обозначения неисполняемые текстовые комментарии — туда мы можем поместить что угодно.

Следующие шесть строк кода нас не интересуют — они просто настраивают сегментные регистры так, чтобы указатель стека (SP) знает, где находится наш удобный стек временных данных и где расположен сегмент данных (DS).Как Как уже упоминалось, сегменты — это ужасно беспорядочный способ обработки памяти из старых 16-битных дней, но мы просто настроили сегмент регистрирует и забывает о них. (Ссылки на 07C0h — это эквивалентное местоположение сегмента, в котором загружается BIOS. наш код, поэтому мы начнем оттуда.)

В следующей части происходит самое интересное. Строка mov si, text_string говорит: скопируйте расположение текстовую строку ниже в регистр SI. Достаточно просто! Затем мы используем вызов , который похож на GOSUB в BASIC или вызов функции в C.Это означает: перейти к указанному разделу кода, но приготовиться вернуться сюда, когда были сделаны.

Откуда код знает, как это сделать? Что ж, когда мы используем команду call , CPU увеличивает положение регистра IP (указателя инструкции) и помещает в стек. Вы можете вспомнить из предыдущее объяснение стека гласило, что это механизм хранения памяти в порядке очереди. Весь этот бизнес с указатель стека (SP) и сегмент стека (SS) в начале очищают пространство для стека, так что мы можем удалить временные номера там, не перезаписывая наш код.

Итак, вызов print_string говорит: переходите к подпрограмме print_string, но нажимайте местоположение следующего в стек, так что мы можем удалить позже и возобновить выполнение здесь. Казнь подскочила переход к print_string: — эта процедура использует BIOS для вывода текста на экран. Сначала мы помещаем 0Eh в регистр AH (старший байт AX). Затем у нас есть инструкция lodsb (загрузка байта строки), которая извлекает байт данных из места, на которое указывает SI, и сохраняет его в AL (младший байт AX).Далее мы используем cmp , чтобы проверить, равен ли этот байт нулю — если да, это конец строки, и мы выходим из печати (переход к . Сделано этикетка).

Если это не ноль, мы вызываем int 10h (прерываем наш код и переходим в BIOS), который считывает значение в регистр AH (0Eh), который мы установили ранее. Ах, говорит BIOS — 0Eh в регистре AH означает «печатать символ в AL Зарегистрируйтесь на экране! «. Таким образом, BIOS печатает первый символ в нашей строке и возвращает из int вызов.Затем мы переходим к метке .repeat , которая снова запускает процесс — lodsb для загрузки следующий байт от SI (он каждый раз увеличивает SI), посмотрите, равен ли он нулю, и решите, что делать. ret at конец нашей процедуры печати строк означает: «мы закончили здесь — возвращаемся в то место, где мы были вызывает ed, вставляя код из стека обратно в регистр IP «.

Итак, у нас есть демонстрация цикла в отдельной программе.Вы можете видеть, что text_string label находится рядом с потоком символов, который мы вставляем в нашу ОС, используя db . Текст в апострофы, чтобы NASM знал, что это не код, и в конце у нас есть ноль, чтобы сообщить нашему print_string рутина, что мы в конце.

Подведем итоги: мы начинаем с настройки сегментных регистров, чтобы наша ОС знала, где находится указатель стека и исполняемый код находится. Затем мы указываем регистр SI на строку в нашем двоичном файле ОС, и вызывает наш процедура печати строк.Эта процедура просматривает символы, на которые указывает SI, и отображает их, пока не найдет ноль, после чего он возвращает урн обратно в код, который вызывает . Тогда jmp Строка $ говорит: продолжайте переходить к той же строке. (‘$’ В NASM обозначает текущую точку кода.) Это устанавливает бесконечный цикл, чтобы отображалось сообщение и наша ОС не пыталась выполнить следующую строку!

Последние две строки интересны. Чтобы ПК распознал допустимый загрузочный сектор гибкого диска, он должен быть ровно 512 байт в size и заканчиваются числами AAh и 55h (подпись загрузки).Итак, первая из этих строк гласит: дополните полученный двоичный файл должен иметь размер 510 байт. Затем во второй строке используется dw (определите слово — два байта), содержащий вышеупомянутая загрузочная подпись. Вуаля: загрузочный файл размером 512 байт с правильными номерами в конце для BIOS признать.


Дом

Давайте создадим нашу новую ОС. Как уже упоминалось, эти инструкции предназначены для Linux; если вы используете Windows, см. отдельное руководство. В окне терминала в домашнем каталоге введите:

 nasm -f bin -o myfirst.bin myfirst.asm
 

Здесь мы собираем код из нашего текстового файла в необработанный двоичный файл инструкций машинного кода. С -f bin , мы сообщаем NASM, что нам нужен простой двоичный файл (не сложный исполняемый файл Linux — мы хочу, чтобы это было как можно проще!). Часть -o myfirst.bin сообщает NASM о необходимости создания результирующего двоичного файла. в файле myfirst.bin.

Теперь нам нужен образ виртуального гибкого диска, на который мы можем записать ядро ​​размером с загрузчик.Копировать mikeos.flp из каталога disk_images / пакета MikeOS в ваш домашний каталог и переименуйте его myfirst.flp . Затем введите:

 dd status = noxfer conv = notrunc if = myfirst.bin of = myfirst.flp
 

Это использует утилиту ‘dd’ для прямого копирования нашего ядра в первый сектор образа гибкого диска. Когда это готово, мы можем загрузить нашу новую ОС с помощью эмулятора ПК QEMU следующим образом:

 qemu-system-i386 -fda myfirst.flp 

И вот вы где! Ваша ОС загрузится на виртуальном ПК.Если вы хотите использовать его на реальном ПК, вы можете написать Образ дискеты на настоящую дискету и загрузитесь с нее, или сгенерируйте ISO-образ компакт-диска. Для последнего сделайте новый каталог с именем cdiso и переместите в него файл myfirst.flp . Затем в вашем домашний каталог, введите:

 mkisofs -o myfirst.iso -b myfirst.flp cdiso /
 

Создает ISO-образ компакт-диска под названием myfirst.iso с эмуляцией загрузочной дискеты, используя образ виртуальной дискеты из прошлого.Теперь вы можете записать этот ISO-образ на CD-R и загрузить с него свой компьютер! (Обратите внимание, что вам нужно чтобы записать его как прямой ISO-образ, а не просто скопировать на диск.)

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



Идем дальше

Итак, теперь у вас работает очень простая операционная система на основе загрузчика.Что дальше? Вот несколько идей:

  • Добавьте больше подпрограмм — у вас уже есть print_string в вашем ядре. Вы можете добавить подпрограммы для получения строк, переместить курсор и т. д. Поищите в Интернете вызовы BIOS, которые можно использовать для эти.
  • Загрузить файлы — Загрузчик ограничен 512 байтов, поэтому у вас не так много места. Вы можете загрузить загрузчик последующие секторы на диске в ОЗУ и перейти к этой точке, чтобы продолжить выполнение.Или вы можете прочитать о FAT12, используемой файловой системе на флоппи-дисководах, и реализовать это. (См. Источник / bootload / bootload.asm в .zip MikeOS для реализации.)
  • Присоединяйтесь к другому проекту — Это руководство было написано Майком Сондерсом, ведущим разработчиком MikeOS. Это простая 16-битная операционная система на языке ассемблера x86, и когда-то вы полностью уверены в изложенных здесь концепциях, вы сможете копаться в коде и добавлять функции. См. Руководство разработчика системы ссылку на главной странице для получения дополнительной информации.


.

Создание операционной системы (ОС) на языке ассемблера

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

Недавно Райан обратил свое внимание на компьютеры.Например, всего несколько минут назад он отправил мне электронное письмо с вопросом: «Можно ли создать операционную систему на языке ассемблера? Кроме того, зачем нужна сборка в наши дни таких языков, как C / C ++ и Java, когда память настолько дешева? »

Итак, я должен признать, что у меня было искушение послать короткий, быстрый и легкий (для меня) ответ, но я помню, как все было для меня запутанным вначале — плюс я немного навязчиво-компульсивен по поводу такого рода вещи — поэтому я ответил следующим образом; Мне было бы интересно услышать ваши мысли о том, как я все это изложил.

Привет, Райан. Как обычно, в твоем вопросе больше, чем кажется на первый взгляд LOL. Начнем с того факта, что процессор (мы сосредоточимся на микропроцессорах / MPU или микроконтроллерах / MCU, но это применимо ко всему, вплоть до мэйнфреймов) в конечном итоге выполняет так называемые «инструкции машинного кода». В основном это числа, представляющие инструкции или данные, где число «x» может указывать на инструкцию «Добавить», число «y» может указывать на инструкцию «Сравнить» и так далее.

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

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

На самом деле это отличный пример «начальной загрузки»; то есть подтягиваться за шнурки. Вот как все пойдет. Вы бы определили очень простой язык ассемблера как упражнение с карандашом и бумагой. Затем вы должны написать очень элементарный ассемблер на своем языке ассемблера — снова используя карандаш и бумагу — и вручную собрать этот элементарный ассемблер в машинный код.

Здесь все становится интересно. Вы также могли бы написать очень простой текстовый редактор (вероятно, типа, известного как ca «Line Editor») на своем языке ассемблера в виде упражнения на бумаге и карандашом, и вы вручную собрали бы этот простой редактор в машинный код.

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

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

Теперь давайте рассмотрим, например, современный язык, такой как Си. Как вы знаете, мы используем программу-редактор для создания нашего исходного кода на C, затем мы запускаем этот код через программу компилятора и — в конечном итоге — нам предоставляется эквивалент машинного кода («исполняемый»).

Первый вопрос, который нам нужно задать: «Откуда взялась программа компилятора?» Фактически, если бы вы были человеком, создавшим компилятор, то первая версия (очень простой компилятор C) была бы написана на языке ассемблера и прошла через вашу программу ассемблера для генерации версии компилятора с машинным кодом.Эта первая версия вашего компилятора C может поддерживать только подмножество языка C — ровно настолько, чтобы вы могли начать работу.

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

После этого вы начнете цикл по созданию новых, более сложных версий вашего компилятора C, где каждая из них была скомпилирована в машинный код с использованием предыдущей версии.И снова вы будете «подтягиваться за шнурки». (В целях наших обсуждений до сих пор мы предполагаем, что переходим непосредственно от сборки к C. На самом деле были и другие языки, такие как FORTRAN, между ними, и более чем вероятно, что кто-то мог создать компилятор FORTRAN на сборке, а затем использовал FORTRAN для захвата первого компилятора C, но давайте не будем блуждать по траве.)

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

Мы уже развлекаемся (LOL)? Хорошо, допустим, мы хотим создать программу, которая что-то делает; возможно, это игра в Breakout.Мы могли бы создать эту программу на языке ассемблера или C. В прошлом опытные программисты говорили, что они знают множество хитрых приемов, чтобы они могли создавать меньшие и более быстрые программы на языке ассемблера, чем те, которые могут быть созданы с помощью компилятора C. Вероятно, это было правдой, но на это им потребовалось бы гораздо больше времени; кроме того, современные компиляторы C очень сложны и обычно знают те же хитрые приемы, что и программисты.

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

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

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

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

Возвращаясь к вашему исходному вопросу, в случае систем очень низкого уровня, основанных на 8-битных микроконтроллерах, все еще есть довольно много старых программистов, которые программируют исключительно на языке ассемблера. Есть также такие вещи, как семейство программных 8-битных процессорных ядер PicoBlaze, используемых в ПЛИС Xilinx, которые могут быть запрограммированы только на языке ассемблера, потому что никто никогда не удосужился создать для них компилятор C.

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

Доброе горе! Бедный старый Райан. Теперь даже голова болит.Все это кажется таким простым, если вы не обращаете внимания на лежащие в основе механизмы и просто говорите что-то вроде: «Вы записываете свою программу на C, а затем используете компилятор для ее преобразования в исполняемый файл» , но это становится намного более запутанным, когда вы копаетесь глубже в болото.

С другой стороны, я лично считаю, что это действительно интересно. Иногда я думаю о том, что бы произошло, если бы я наткнулся на трещину во времени и пространстве, и мне пришлось бы разрабатывать компьютерную систему (аппаратное и программное обеспечение) с нуля.Эй, я уверен, что мы все беспокоимся о таких вещах… верно?

Итак, что вы думаете о моем объяснении выше? Для вас все это «так себе суп» , или есть элементы этого обсуждения, о которых вы никогда раньше не задумывались? Кроме того, есть ли что-то, что я исказил или упустил, или что, по вашему мнению, мне следовало рассказать более подробно?

.

Язык ассемблера для процессоров x86

Обновлено 28.06.2019

В этом руководстве предполагается, что вы используете 7-е или 8-е издание языка ассемблера . для процессоров x86 , и вы используете Visual Studio 2019. Мы протестировали эти страницы с помощью Community Edition и есть все основания полагать, что Enterprise Edition будет работать так же. Вот как начать работу:
Щелкните здесь правой кнопкой мыши, чтобы загрузить примеры кода и необходимые библиотеки для книги.Разархивируйте загруженный файл в каталог с именем Irvine на диске C. Затем щелкните здесь правой кнопкой мыши, чтобы загрузить zip-файл, содержащий 32-разрядный проект Visual Studio 2019. Вы можете распаковать этот файл в любую папку на вашем компьютере. Наконец, щелкните здесь правой кнопкой мыши, чтобы загрузить zip-файл, содержащий 64-разрядный проект Visual Studio 2019. Вы можете распаковать этот файл в любую папку на вашем компьютере. Теперь вы готовы начать обучение. перечислено ниже. Темы: Нашли ошибку в этом документе? Пожалуйста, напишите Автор.
Необходимая установка для 32-разрядных приложений
После того, как вы загрузили и установили VS 2019 Community Edition, вы может потребоваться установка языковой опции Visual C ++. Сначала посмотрим, есть ли у него уже установлены (как это часто бывает в компьютерных классах колледжей). Выберите Файл >> Создать >> Проект в меню Visual Studio. Вы увидите это диалоговое окно Create a new project . Найдите C ++ в раскрывающемся списке Язык: Примечание. Если вы не видите Visual C ++ в списке, закройте Visual Studio и запустите отдельную программу с именем Visual Studio Installer.Если ваш компьютер находится в лаборатории колледжа, ваша учетная запись может не иметь достаточных прав для запуска этой программы, поэтому вы можете попросить своего руководителя лаборатории сделать это. (Если вы запускаете установщик VS, выберите кнопку Desktop development with C ++ в окне установщика, посмотрите на сводный список справа, чтобы убедиться, что выбран VC ++, и нажмите кнопку Modify в правом нижнем углу окна окно.) Язык Visual C ++ включает Microsoft Assembler (MASM).Чтобы убедиться, что MASM установлен, откройте окно проводника Windows и найдите файл с именем ml.exe в каталоге установки Visual Studio, например C: \ Program Files (x86) \ Microsoft Visual Studio \ 2019 \ Community \ VC \ Tools \ MSVC \ 14.xx.xxxx \ bin \ HostX64 \ x86 . (Символы «x» выше обозначают цифры в номере версии вашей текущей установки VS).
Примеры программ из книги В верхней части этого документа мы объяснили, как загрузить файл с именем Irvine.zip и распаковать в папку C: \ Irvine. Если у вас нет возражений против использования этого местоположение, не меняйте путь. (Примечание для администраторов лаборатории: вы можете указать c: \ Irvine каталог только для чтения.).

Следующие файлы должны появиться в каталоге c: \ Irvine:

Имя файла Описание
b16.asm, b32.asm Пустые шаблоны для 16-разрядных и 32-разрядных исходных файлов на языке ассемблера
GraphWin.inc Включаемый файл для написания приложений Windows
Irvine16.inc Включаемый файл, используемый с библиотекой ссылок Irvine16 (16-битные приложения)
Ирвин 16.lib 16-битная библиотека функций ссылок, используемая в этой книге
Irvine32.inc Включаемый файл, используемый с библиотекой ссылок Irvine32 (32-битные приложения)
Irvine32.lib 32-битная библиотека ссылок Ирвина
Ядро32.lib 32-битная библиотека ссылок для Windows API
Link16.exe 16-разрядный компоновщик Microsoft
Macros.inc Включаемый файл макроса Ирвина (см. Главу 10)
make16_vs2019.bat Пакетный файл Visual Studio 2019 для создания 16-разрядных приложений
SmallWin.inc Малогабаритный включаемый файл, содержащий определения MS-Windows, используемый Irvine32.inc
User32.lib Базовая библиотека компоновки ввода-вывода MS-Windows
VirtualKeys.inc Файл определений кода клавиатуры, используемый Irvine32.inc

Подкаталог с именем Примеры будет содержать все показанные примеры программ. в книге исходный код для 16-, 32- и 64-битных библиотеки и два примера проекта для более ранних версий Visual Studio.

Настройка Visual Studio

Выберите конфигурацию C ++
Visual Studio поддерживает несколько программ языки и типы приложений. Конфигурация языка программирования C ++ наиболее близко соответствует программированию на ассемблере, поэтому мы предлагаем следующие шаги:
  1. Выберите Инструменты >> Импорт и экспорт настроек в меню
  2. Установите переключатель «Импортировать выбранные параметры среды».
  3. Выберите «Нет, просто импортировать… «переключатель
  4. Выберите «Visual C ++» из списка настроек по умолчанию и нажмите кнопку «Далее».
  5. Нажмите кнопку «Готово», затем нажмите кнопку «Закрыть».
  6. Обратите внимание на вкладки слева и справа от рабочего пространства Visual Studio. Закройте вкладки Server Explorer, Toolbox и Properties. (При желании вы можете использовать мышь, чтобы перетащить окно инструмента Обозреватель решений в правую часть рабочей области.) Если вы случайно закроете окно обозревателя решений в будущем, вы можете вернуть его: выберите «Просмотр» в меню и найдите «Обозреватель решений» в списке представлений.
Необязательный шаг: установите размер отступа табуляции
Запустите Visual Studio и выберите Options из Tools . меню. Выберите и разверните элемент Text Editor , выберите All Languages ​​ и выберите Вкладки . При желании вы можете выбрать переключатель Вставить пробелы :

Я предпочитаю устанавливать для параметров Tab Size и Indent Size значения 5.

Учебное пособие: создание и запуск 32-разрядной программы

Теперь вы готовы открыть и построить свой первый 32-разрядный проект.
Открытие проекта

Visual Studio требуется исходный код на языке ассемблера файлы должны принадлежать проекту , который является своего рода контейнером. Проект содержит информацию о конфигурации, такую ​​как расположение ассемблера, компоновщик и необходимые библиотеки. У проекта есть собственная папка, в которой имена и расположение всех принадлежащих ему файлов.

Если вы еще этого не сделали, щелкните здесь правой кнопкой мыши, чтобы загрузить zip-файл, содержащий последнюю версию Visual Studio 2019. проект, настроенный для ассемблера. После загрузки этого файла распакуйте его в свой рабочий каталог. Он содержит образец тестового файла asm с именем AddTwo.asm.

Выполните следующие действия:

  1. Запустите Visual Studio.
  2. Откройте наш образец файла проекта Visual Studio, выбрав File / Open / Project в меню Visual Studio.
  3. Перейдите в свою рабочую папку, в которую вы распаковали файл проекта, и выберите файл с именем Project.sln .
  4. После открытия проекта вы увидите имя проекта в окне обозревателя решений Visual Studio . Вам также следует см. исходный файл на языке ассемблера в проекте с именем AddTwo.asm. Дважды щелкните имя файла, чтобы открыть его в редакторе.

В окне редактора должна появиться следующая программа:

; AddTwo.asm - складывает два 32-битных целых числа.
; Пример из главы 3

0,386
.model flat, stdcall
.stack 4096
Протокол ExitProcess, dwExitCode: dword

.код
главный процесс
mov eax, 5
добавить eax, 6

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

Добавление файла в проект: Если вам нужно добавить файл.asm в открытый проект, выполните следующие действия: (1) Щелкните правой кнопкой мыши имя проекта в окне Visual Studio выберите Добавить, выберите Существующий элемент. (2) В добавить существующий элемент диалоговом окне, перейдите к месту нахождения файла, который вы хотите добавить, выберите имя файла и щелкните кнопку Добавить, чтобы закрыть диалоговое окно.

Соберите программу

Теперь вы соберете (соберете и свяжете) программу-пример. Выберите Build Project из Построить меню.В окне вывода для Visual Studio внизу экрана вы должны увидеть сообщения аналогично следующему, показывая прогресс сборки:

1> ------ Сборка началась: Проект: Проект, Конфигурация: Отладка Win32 ------
1> Сборка AddTwo.asm ...
1> Project.vcxproj -> ... \ Project32_VS2019 \ Debug \ Project.exe
========== Сборка: 1 выполнено успешно, 0 не выполнено, 0 пропущено ==========
 

Если вы не видите эти сообщения, вероятно, проект не был изменен с момента его последней сборки.Нет проблем — просто выберите Rebuild Project из меню Build.

Запустить программу в режиме отладки

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

  1. Убедитесь, что файл исходного кода ASM открыт в окне редактора.
  2. Щелкните мышью вдоль границы слева от mov eax, 5 заявление. На полях должна появиться большая красная точка.
  3. Выберите Начать отладку в меню «Отладка». Программа должна запуститься и остановиться на строке с точкой останова. (При желании вы можете закрыть окна «Инструменты диагностики», «Авто» и «Стек вызовов».)
  4. Нажмите клавишу F10 (называется Step Over ), чтобы выполнить текущий заявление.Продолжайте нажимать F10, пока программа не будет запущена. вызывает оператор .
  5. Маленький черный значок окна должен появиться на рабочем столе Windows или в строке состояния. Окно должно быть пустым, потому что эта программа не отображает никаких результатов.
  6. Нажмите F10 еще раз, чтобы завершить программу.

Точку останова можно удалить, щелкнув ее точку мышью. Взять несколько минут, чтобы поэкспериментировать с командами меню «Отладка».Установите больше точек останова и снова запустите программу.

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

Запуск программы из командной строки: Когда вы собрали и связал проект, файл с именем Project.exe был создан внутри папки проекта \ Debug. Этот файл выполняется при запуске проекта. Вы можете запустить любой EXE дважды щелкнув его имя в проводнике Windows, но часто просто мигают на экране и исчезают.Это потому, что Windows Проводник не приостанавливает отображение перед закрытием командного окна. С другой стороны, вы можете открыть окно командной строки, перейти к Каталог отладки и запустите Project.exe, набрав «Project» (без кавычек). Вам нужно будет немного почитать в Windows команд оболочки, если вы планируете использовать командную строку.

Чтобы удалить исходный файл из окна Visual Studio, щелкните его имя правой кнопкой мыши и выберите Удалить .Файл не будет удален из файловой системы. С другой стороны, если вы хотите удалить файл, выберите его и нажмите клавишу Del.

Регистры

Вскоре вы захотите отображать регистры ЦП при отладке вашего программы. Вот как сделать их видимыми: Сначала в меню Инструменты >> Параметры выберите Отладка на левой панели, и выберите Включить отладку на уровне адресов . Следующий, установите точку останова в исходном коде для исполняемого оператора, запустите свою программу в режиме отладки, выберите Windows в меню Debug , а затем выберите Регистры из раскрывающегося списка.

Если вы не видите команду «Регистры» в раскрывающемся меню «Отладка >> Windows» (что, похоже, относится к VS2019 Community Edition, существует способ добавить кнопку «Регистры» на панель инструментов отладки. Вот как это сделать. it:
  1. Не выполняя отладку, выберите Настроить в меню Инструменты.
  2. Щелкните вкладку Commands , выберите вкладку Toolbar и выберите Отладка из списка панелей инструментов.
  3. Нажмите кнопку Добавить команду . В списке Категории выберите Отладка .
  4. Выберите регистров из списка команд, нажмите кнопку ОК, чтобы закрыть диалоговое окно.
  5. Нажмите кнопку Закрыть , чтобы закрыть диалоговое окно «Настройка». Ты должен сейчас увидите новую кнопку на панели инструментов отладки, которая выглядит как маленький прямоугольник, содержащий «0X», когда вы начинаете отладку программы.
Окно регистров может появиться прикрепленным к верхней части рабочей области, но вы может оказаться полезным разместить окно поверх рабочего места.Просто возьми заголовок окна с помощью мыши и перетащите его в центральную область. Вы также хотите отобразить флаги процессора. Для этого щелкните правой кнопкой мыши в окне регистров и проверьте слово Flags во всплывающем меню. Вы можете прервать сеанс отладки в любое время, выбрав Стоп. Отладка из меню «Отладка». Вы можете сделать то же самое, нажав на бордовая квадратная кнопка на панели инструментов. Чтобы удалить точку останова из программы, щелкните ее красную точку, чтобы она исчезла.Напоминаем, что вы можете просмотреть наше руководство: Использование отладчика Visual Studio
Создание и запуск других программ

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

  • Чтобы удалить программу из проекта без удаления файла, щелкните правой кнопкой мыши его имя в окне обозревателя решений .В контекстном меню выберите Удалить . Если вы передумаете и решите чтобы добавить его обратно в проект, щелкните правой кнопкой мыши в том же окне, выберите Добавить, выберите Существующий элемент, и выберите нужный файл добавить.
Добавление файла в проект

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

  1. Удалите файл AddTwo.asm из вашего проекта.
  2. Добавьте ссылку на файл Примеры \ ch03 \ AddTwoSum.asm в проект.
  3. Создайте и запустите проект.
Копирование исходного файла

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

Вернуться к началу







Учебное пособие: создание и запуск 64-разрядной программы

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

Выполните следующие шаги по порядку:

  1. Щелкните здесь правой кнопкой мыши, чтобы загрузить файл Project64_VS2019.zip и распаковать его в свой рабочий каталог.
  2. В Visual Studio 2019 выберите «Открыть проект» в меню «Файл», перейдите в папку Project64_VS2019 и выберите файл с именем Project.sln .
  3. Вы собираетесь добавить в проект существующий файл исходного кода. Чтобы для этого щелкните правой кнопкой мыши проект в окне обозревателя решений, выберите Добавить , выберите Существующий Элемент , перейдите в папку «Примеры \ ch03 \ 64 bit» книги, выберите AddTwoSum_64.asm и нажмите кнопку Добавить , чтобы закрыть диалоговое окно.
  4. Откройте файл AddTwoSum_64.asm для редактирования, дважды щелкнув его имя файла в окне обозревателя решений.

В окне редактора должна появиться следующая программа:

; AddTwoSum_64.asm - пример главы 3.

ExitProcess proto

.данные
сумма qword 0

.код
главный процесс
   mov rax, 5
   добавить rax, 6
   сумма mov, rax

   mov ecx, 0
   вызов ExitProcess

главный конец
конец
 
(Обратите внимание, что точкой входа в программу является основная процедура.Если вы хотите использовать другое имя для своего стартапа в ваших собственных программах, вы можете изменить этот параметр, выбрав Свойства в меню Проект, а затем выбрав Компоновщик / Дополнительно / Точка входа.)
Соберите программу
Выберите Build Project из меню Build. Вы должны увидеть текст, написанный в окне вывода Visual Studio, как показано ниже:
1> ------ Сборка началась: Проект: Проект, Конфигурация: Отладка x64 ------
1> Сборка AddTwoSum_64.как м...
1> Project64_VS2019.vcxproj -> ... \ Project64_VS2019 \ x64 \ Debug \ Project.exe
========== Сборка: 1 выполнено успешно, 0 не выполнено, 0 обновлено, 0 пропущено ==========
 
Если вы не видите этих сообщений, вероятно, проект не был изменен. с момента последней постройки. Нет проблем — просто выберите Rebuild Project из Построить меню. Для запуска и отладки 64-разрядных программ используются те же команды Visual Studio, что и для 32-разрядных программ.

Вернуться к началу







Создание 16-битных программ (главы 14-17)

Только главы с 14 по 17 требуют создания 16-разрядных приложений. За исключением нескольких исключений, которые отмечены в книге, ваш 16-битный приложения будут работать под 32-битными версиями Windows (Windows XP, Windows Vista, Windows 7).

Если вы заинтересованы в запуске 16-битных программ под 64-битной Windows, вы потребуется включить функцию под названием NTVDM.) Щелкните здесь, чтобы прочитать веб-сайт с инструкциями о том, как это сделать. Другая альтернатива, которую вы, возможно, захотите изучить, — это установить виртуальную машину (с помощью бесплатной программы VirtualBox от Oracle) и установить 32-разрядную Windows на виртуальной машине. Примеры программ книги в главах 1-13 были успешно использованы. протестировано в 32-битных Windows 7,8 и 10. С другой стороны, многие программы из глав 14-17 не будут работать ни в одной из операционных систем Microsoft, более поздних, чем Windows 98, поскольку они полагаются на прямой доступ к оборудованию и системной памяти.Вы не можете напрямую запускать 16-битные приложения в любой 64-битной версии Windows.

Если вы планируете создавать 16-битные приложения, вам нужно добавить две новые команды в меню Инструменты Visual Studio. Чтобы добавить команду, выберите External Tools из меню Tools. Следующий диалог появится, хотя многие элементы в вашем списке слева будет отсутствовать. Загрузите пакетный файл здесь (переименуйте расширение .txt в.bat после загрузки): make16_vs2019.txt.

Шаг 1. Создайте 16-разрядную команду ASM сборки

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

Нажмите кнопку Применить , чтобы сохранить команду.

Шаг 2. Создайте 16-разрядную команду ASM «Выполнить»

Снова нажмите кнопку «Добавить» и создайте новую команду с именем «Выполнить 16-разрядный». ASM :

Снимите флажок «Закрыть при выходе» и нажмите кнопку «ОК», чтобы сохранить команду и закрыть внешние инструменты. диалог.

Тестирование ваших новых 16-битных команд

Чтобы протестировать новые 16-разрядные команды, закройте все открытые проекты Visual Studio. Затем выберите Файл | Открыть | Файл из меню и выберите файл с именем 16-bit.asm из папки ch03 в примерах программ книги. Выберите Build 16-bit. ASM из меню Инструменты. Должно появиться следующее командное окно, показывает успешное выполнение ассемблера и компоновщика, после чего списком всех файлов, относящихся к этой программе:

Нажмите клавишу, чтобы закрыть окно.Далее вы запустите программу. Выбрать Запустите 16-битный ASM из меню «Инструменты». Появится следующее окно, хотя содержимое всех регистров, кроме EAX, будет другим:

Нажмите клавишу, чтобы закрыть окно.

Вы завершили настройку для сборки и запуска 16-битной сборки. языковые программы.

Вернуться к началу



Подсветка синтаксиса в исходном коде

Когда текстовый редактор использует подсветку синтаксиса, языковые ключевые слова, строки, а другие элементы отображаются разными цветами.Visual Studio выделяет MASM зарезервированные слова и строки, как показано в следующем примере:

Это не произойдет автоматически, но вы можете создать определение синтаксиса файл с именем Usertype.dat, содержащий ключевые слова MASM. Затем, когда Visual Studio запускается, читает файл синтаксиса и выделяет Ключевые слова MASM.

Если вы решите использовать встроенный в Visual Studio выделитель синтаксиса MASM, выполните следующие действия для его настройки: 1) Загрузите этот Usertype.dat (заключен в ZIP-файл) данные здесь в папку, в которой у вас есть разрешения на чтение / запись. Извлеките его из zip-архив. 2) Закройте Visual Studio. 3) Скопируйте Usertype.dat в C: \ Program Files (x86) \ Microsoft Visual Studio \ 2019 \ Community \ Common7 \ IDE папка. Windows отобразит диалоговое окно подтверждения перед копированием файла. 4) Откройте Visual Studio, выберите Options из в меню Инструменты выберите Текстовый редактор и выберите Расширение файла .В правой части диалогового окна (показано ниже) введите asm в качестве расширение, выберите Microsoft Visual C ++ из списка редактора и нажмите кнопку Добавить . Нажмите кнопку ОК , чтобы сохранить изменения.

Откройте свой проект и отобразите файл ASM. Вы должны увидеть выделение синтаксиса в редакторе. Eсть глюк в выделении — строка комментария на ассемблере начинается с символа точка с запятой, которую C ++ не распознает.Но это простой обходной путь: добавьте дополнительный // сразу после точки с запятой, как это, что приведет к тому, что комментарии будут имеют свой обычный зеленый цвет:
; // AddTwo.asm - складывает два 32-битных целых числа.
; // Пример из главы 3
Вернуться к началу

Был ли EXE-файл вашей программы заблокирован антивирусным сканером?

Программное обеспечение антивирусного сканера значительно улучшилось за последние годы, как и количество вирусов (в настоящее время один веб-сайт сообщает о 50 000).Из-за этого антивирусный сканер вашего компьютера может сообщить о ложном срабатывании при создании программы и отказать вам в ее запуске. Есть несколько обходных путей: (1) Вы можете добавить папку bin / debug вашего проекта в список исключений в вашей конфигурации антивируса. Это мое предпочтительный подход, и он почти всегда работает. (2) Вы можете приостановить работу антивирусного сканера в реальном времени, но это на короткое время сделает вас уязвимыми для вредоносных программ. Если вы выберете этот вариант, обязательно отключите компьютер от Интернета на время.Вернуться наверх

Совет: Если окно Solution Explorer не отображается отображается, выберите Solution Explorer в меню View .Кроме того, если вы не видите main.asm в обозревателе решений окно, оно может быть скрыто за другим окном. Чтобы вывести его на передний план, щелкните значок Обозреватель решений из вкладок, отображаемых в нижней части окна.

.Проекты

— OSDev Wiki

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

Операционные системы имеют высокий уровень смертности: с 2004 по 2006 год 112 из 213 проектов ОС исчезли из Интернета. И если посмотреть, как часто эти проекты запускаются с помощью форума объявлений о проектах ОС, за тот же период было объявлено о 68 проектах! В настоящее время общее количество проектов составляет 175, но только 58 из них являются активными (по состоянию на 1 января 2018 г.), и только 62 были обновлены хотя бы один раз с 2018 г. (три из которых были заброшены), а 27 — с 2019 г.Поддерживайте актуальность этого списка, исправляя его, если вы видите устаревшую информацию.

Операционные системы, не обновлявшиеся с 2015 года, теперь находятся в Заброшенных проектах.
Особенно продвинутые и успешные операционные системы также можно найти в Notable Projects.

Содержание: A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 9

Доступ2

Acess2 — это ядро ​​и операционная система, разработанные для того, чтобы делать то же, что и Linux, с возможностью настройки в любой конкретной ситуации.Однако, в отличие от Linux, здесь нет необходимости поддерживать обратную совместимость ни с чем. Он имеет простую, но расширяемую VFS, которая в настоящее время поддерживает сети VFAT и Ext2, IPv4 / IPv6 с TCP / UDP, USB-входом и хранилищем. Недавно этот проект был перемещен на GitHub, но его старый репозиторий git — с устаревшими исходниками и некоторой полезной документацией — можно найти здесь: http://git.mutabah.net/?p=acess2.git;a=summary. Образ устаревшей дискеты v0.14 доступен на его старой странице: имя пользователя — root, пароль пуст.Можете попробовать собрать новую дискету из последних исходников! (замечена программная гниль, но это поправимо)

thePowersGang

Открытый исходный код; внутри архива исходного кода есть неработающие символические ссылки /Kernel/arch/x86_64/rme.c и /Kernel/arch/x86_64/rme.h на файлы эмулятора реального режима, которые доступны здесь — https://github.com/thepowersgang/ rme2

http://www.mutabah.net/acess2/

Последняя фиксация: 22.06.2016, в настоящее время отменена — автор переключился на свой другой проект, Rust OS (https : // github.com / thepowersgang / rust_os)

Операционная система Amiga Research,

AROS стремится создать бесплатную AmigaOS с открытым исходным кодом, подобную ОС, и сделать ее лучше оригинала. Наша домашняя страница: http://aros.sourceforge.net

Ола Дженсен, ola [at] aros [dot] org

Открытый исходный код (MPL-like)

http://www.aros.org

Последнее обновление: 2019-02-25, активен

Проект Аполлон

Проект Apollo — это микроядро, разработанное для максимальной переносимости.Тщательно следуя философии UNIX, не будучи самим unix. Проект существует около 6 лет, за это время было полностью переписано около 8 кодов.

ник [at] primis [dot] org

Открытый исходный код (MIT)

https://github.com/primis/Apollo

Последняя фиксация: 01.01.2019 -07, активен; Последний выпуск: 24.04.2014

Водный

Aqeous — это новая полностью созданная с нуля 32-разрядная ОС pmode Not-a-UNIX (прямо сейчас это ядро) с поддержкой многопроцессорных систем в стиле SMP, каждый из которых использует многоуровневое планирование очередей с обратной связью, реализуя собственную файловую систему AqFS (также драйвер AqFS на стороне Windows для связи), Довольно хорошая оболочка, Довольно аккуратные графические драйверы VESA, Система графического интерфейса окна компостирования с двойной буферизацией и альфа-смешиванием, примитивный механизм рендеринга масштабируемых шрифтов и драйверы мыши и клавиатуры вне курса, Поддержка сценариев оболочки (нравиться .bat в Windows) и т. д. Многие вещи находятся в активной разработке и еще даже не в альфе. Код может выглядеть довольно глупо, но да, это не так уж и плохо надолго. Цель состоит в том, чтобы сделать что-то, на чем можно было бы открыть facebook и отправить мне привет 🙂 В настоящее время он поддерживает только Qemu 🙁 Но над этим тоже работаю.

ashishkmr472 [at] gmail [dot] com

Открытый исходный код

https://github.com/AshishKumar4/Aqeous

Последнее обновление: 2018-09-18

AQUA OS

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

inobulles [at] gmail [dot] com

GPLv2

https://obiwac.wordpress.com/aqua-os/

Последнее обновление: 2018-04- 09

AquilaOS — это UNIX-подобная операционная система, полностью совместимая с POSIX. Его дизайн основан на универсальном и надежном подходе.Многие интерфейсы POSIX уже поддерживаются, включая многопоточность, и многие приложения, совместимые с POSIX, были перенесены.

manwar [at] ieee [dot] org

Открытый код (GNU GPLv3)

http://aquilaos.com

Последнее обновление: 23.01.2019

Асуро

Asuro — операционная система x86, разработка которой началась в 2015 году как академический проект.Написанная почти полностью на Freepascal, с NASM, используемым только для начальной загрузки и минимальных низкоуровневых подпрограмм, Asuro — это операционная система, предназначенная исключительно для любителей, которая очень сильно отличается по дизайну от любой основной ОС тем, что использует виртуальную машину / SE для запуска чего-либо, кроме кода ядра.

Кирон Моррис, kjm [at] kieronmorris [dot] me
Аарон Ханс, ах [в] aaronhance [точка] мне

Открытый исходный код

https: // www.spexeah.com/index.php/asuro/

Последний коммит: 2019-03-12

Аура

Aura является частью более крупной идеи Project Asiago. Его цель — заново изобрести все устаревшие системы в одной единой установке. Аура — это лишь ядро ​​всего этого.

Крис Смит, Крис [at] hichris.com

Открытый исходный код (GNU GPLv3)

https: // github.com / projectasiago / aura

Последняя фиксация: 2018-03-09

AwooOS

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

Эллен Дэш, я [at] duckie [dot] co

Открытый исходный код (MPL)

https: // github.com / awooos / awooos

Последняя фиксация: 2019-02-16

Металл

BareMetal — 64-битная ОС для компьютеров на базе x86-64. ОС написана полностью на ассемблере, а приложения могут быть написаны на ассемблере или C / C ++. Две основные цели BareMetal — это использование в образовательных целях при изучении низкоуровневого программирования ОС на 64-битной ассемблере и использование в качестве основы для узла высокоскоростной обработки данных.Исходный код хорошо документирован и находится в свободном доступе. Начиная с версии 0.4.9 BareMetal OS официально поддерживает несколько процессоров, управление памятью и связь через Ethernet. Больше информации здесь — http://www.returninfinity.com/

Ян Сейлер, ian.seyler [at] returninfinity [dot] com

Открытый исходный код

https://github.com/ReturnInfinity/BareMetal-OS

Последний коммит : 2018-12-04

BCOS

BCOS — это практичная распределенная операционная система, изначально предназначенная для компьютеров, совместимых с 80×86 / PC.В общем, BCOS предназначен (в конечном итоге) для того, чтобы группа компьютеров, соединенных сетью (кластер компьютеров), работала как один компьютер с несколькими пользователями.

Брендан Троттер, btrotter [at] gmail [dot] com

Собственный 🙁

http://bcos.hopto.org/

Последнее обновление: 2018-03 -11

Вельзевул

Вельзевул (Повелитель мух) включает гибридное ядро, сопровождаемое библиотеками и приложениями, написанными в основном на C ++, служащими платформой для разработки и экспериментов с функциями ядра / ОС / среды выполнения.В настоящее время он нацелен на AMD64, а позже планируется поддержка архитектур IA-32 и ARM. Он стремится стать чистой, современной и эффективной операционной системой для серверов и рабочих станций.

contact [at] vercas [dot] com

Открытый исходный код (BSD-подобный)

https://github.com/vercas/Beelzebub

Последняя фиксация: 2018 -12-22

BeeOS

Простое «Unix-подобное» ядро ​​x86, пытающееся быть совместимым с POSIX.В настоящее время у проекта нет каких-либо долгосрочных амбиций, он просто хочет стать хорошим средством обучения операционным системам и темам программирования низкого уровня. Не исключено использование в будущем «в полевых условиях», особенно когда порт ARM будет готов.

davxy [at] datawok [dot] net

Открытый исходный код (GNU LGPLv3)

https://github.com/davxy/beeos

Последний коммит: 2020- 06-06, активен

BlueKernel

BlueKernel — это простая конструкция микроядра, предназначенная для студентов.Он имеет упреждающую многозадачность с потоками, передачей сообщений и виртуальной памятью. В настоящее время он предназначен для процессоров IA-32, но конструкция строго разделена на уровень аппаратно-зависимых механизмов с независимым уровнем политик поверх этого. У него есть собственный базовый загрузчик, который загружает ядро ​​и драйвер диска. Он также имеет базовый драйвер дисплея в текстовом режиме и драйвер клавиатуры. Как и в большинстве микроядер, драйверы запускаются в пользовательском пространстве и помогают продемонстрировать передачу сообщений и прерывания.Когда система запускается, она загружает сервер, который позволяет пользователю загружать свои собственные процессы. Существуют очень простые примеры пользовательских программ для демонстрации потоков, передачи сообщений и прерываний. Веб-сайт написан как учебник, чтобы объяснить, как все это работает, с упором на реализацию, а не на теорию.

http://bluekernel.com.au/#intro,Download%20+%20Contact

Creative Commons, http://creativecommons.org/licenses/by-nc-nd/4.0/

http://www.bluekernel.com.au

Первоначальный выпуск: v1.0, последний выпуск: декабрь 2018 г.

BoneOS

BoneOS — это операционная система для всех, созданная всеми. Цель состоит в том, чтобы сделать операционную систему для «всех». От программистов до обычных пользователей. Эта операционная система в настоящее время поддерживает x86 и x64. Позже мы перейдем к другим архитектурам и платформам, таким как MIPS, PowerPC, ARM и т. Д…

Команда Bone OS (https://github.com/Bone-Project/BoneOS)

Открытый исходный код (GNU GPLv3)

https://github.com/Bone-Project/BoneOS

Последняя фиксация: 04.05.2017, Последняя версия: 05.02.2017; сайт теперь сайт на японском языке об онлайн-казино

ChaiOS

Модульная мультиплатформенная ОС.Даже библиотека ядра C динамически связана (с использованием очень простых дубликатов). Написано на Visual C ++ и NASM.

solocle: chaios.project [at] gmail [dot] com, личное: bellezzasolo [at] gmail [dot] com

Открытый исходный код (MIT)

https://github.com/ ChaiSoft / ChaiOS

Последняя фиксация: 17.03.2019

Ктулху OS

Cthulhu OS — это активно развивающееся микроядро на базе x86-64, использующее C11 и настраиваемую libc.В настоящее время поддерживает простой код пользовательского пространства. Долгосрочные цели включают стандартную операционную систему для настольных ПК. Cthulhu OS поддерживает создание процессов из initramfs (называемых rlyeh) и управление памятью + системными вызовами. К сожалению, у него ужасный набор инструментов, и его очень сложно (если не невозможно) скомпилировать в современной среде разработки, если автор этого проекта не исправит его.

Питер Ванусаник, администратор [at] en-circle [dot] com

Открытый исходный код (MIT)

http: // enerccio.github.io/Cthulhu-OS/

Последняя фиксация: 31.01.2016, кажется неактивным

Cyjon

Простая многозадачная операционная система с чистым кодом, написанная на чистом ассемблере, для 64-разрядных процессоров семейства AMD64.

Нет контактной информации

Лицензия GPL-3.0

https://github.com/Blackend/Cyjon/

Последнее обновление: 14.08.2020

Рассвет

Dawn OS — это операционная система высокого уровня для набора команд SUBLEQ.Он поддерживает SMP, 64-битную адресацию памяти, многозадачность, имеет встроенный компилятор C, виртуальную клавиатуру и собственный сетевой стандарт P2P с автоматической пересылкой между клиентами, а также содержит различные встроенные инструменты, такие как рисование, текстовый редактор, звук. игрок, шахматы, пианино, амеба

http://gerigeri.uw.hu/DawnOS/download.html

Бесплатное программное обеспечение

http://gerigeri.uw.hu/DawnOS/index.html

Последний выпуск: 13.02.2019, активен

DreamOs

Самодельная операционная система, разработанная на C и asm для архитектур x86.

Иван Гуаландри, контактная информация внизу страницы Github

Открытый исходный код (GNU GPLv3)

https://github.com/inuyasha82/DreamOs

Последний коммит: 2018-09-18

Dux

Операционная система x86 с возможностью загрузки модулей, запущена в 2008 г.

Эллен Дэш, я [at] duckie [dot] co

Открытый исходный код (MIT)

https: // github.com / duckinator / dux

Последняя фиксация: 2017-12-05

Побег

Escape — это 32-разрядная операционная система с микроядром для X86, которая поддерживает многозадачность и многопоточность. Он реализован на ANSI C, C ++ и немного ассемблере, и большинство его частей похожи на UNIX. Цель состоит в том, чтобы поэкспериментировать с ним и узнать как можно больше об операционных системах, оборудовании и так далее.

Нильс Асмуссен, nils [at] script-solution [dot] de

Открытый исходный код (GNU GPLv2)

https: // github.com / Nils-TUD / Escape

Последняя фиксация: 2018-07-12

Эйнхерий

Вычислительная среда Forth для компьютеров Mac PowerPC.

Константин Чолокачвили, Константин [dot] tcholokachvili [at] protonmail [dot] com

Открытый код (MIT)

https://github.com/narke/Einherjar


Последнее обновление: 2020-03-16

Fiwix

Fiwix — это ядро ​​операционной системы, написанное с нуля, основанное на архитектуре UNIX и полностью ориентированное на совместимость с POSIX.

Jordi Sanfeliu, jordi [at] fiwix [dot] org

Proprietary 🙁 (автор обещает, что он станет открытым исходным кодом в версии 1.0)

http://www.fiwix.org/

Последний выпуск: 2018-08-04

Флинг ОС

Fling OS — это образовательная операционная система с полной технической документацией, цель которой — иметь полные справочные и учебные статьи по каждому аспекту ее кода.По состоянию на сентябрь 2015 года у них было ядро ​​C # с драйвером ELF и поддержкой USB 2.0 для x86, компилятор C # AOT и кроссплатформенное (x86 / MIPS) ядро ​​проверки компилятора. 17 сентября 2015 года они выпустили более 30 статей и серию из 10 обучающих видеороликов по началу работы, которые прошлым летом спонсировала компания Imagination Technologies. Стабильное ядро ​​ядра, включая драйверы USB 2.0 и ELF. Также первый выпуск их компилятора AOT C # to x86 / MIPS и ядра проверки компилятора. Промышленность спонсирует и сотрудничает с Бристольским университетом.Наша домашняя страница: http://www.flingos.co.uk

Эдвард Наттинг, osdev [at] flingos.co.uk

Открытый исходный код (GNU GPLv2)

https://github.com/FlingOS/FlingOS

Последний коммит : 2017-10-30

FreeDOS

Сегодня FreeDOS идеально подходит для всех, кто хочет связать версию DOS без необходимости платить роялти за использование DOS.FreeDOS также будет работать на старом оборудовании и встроенных системах. FreeDOS также является бесценным ресурсом для людей, которые хотели бы разработать свою собственную операционную систему. Хотя существует множество бесплатных операционных систем, другой бесплатной операционной системы, совместимой с DOS, не существует. Источники здесь: http://www.ibiblio.org/pub/micro/pc-stuff/freedos/files/repositories/1.2/

Джим Холл, списки рассылки на http://www.freedos.org/lists/

Открытый исходный код (GNU GPLv2)

http: // www.freedos.org

Последний выпуск: 24.08.2018

Фадж

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

Йенс Найберг, Йенс [точка] Нюберг [at] gmail [точка] com

Открытый исходный код (MIT)

http: // github.com / jezze / fudge /

Последняя фиксация: 2018-12-30, активен

FYSOS

32-разрядная и 64-разрядная операционная система Intel / AMD, включая самое современное оборудование, в частности USB и сопутствующее оборудование.

Бен Лант, fys [at] fysnet [dot] net

В настоящее время закрытый исходный код

http: //www.fysnet.net / fysos.htm

активный

Самодельная операционная система с микроядром для платформы IA32 (x86). Проект написан на C ++ и Assembly. Особенности: поддержка многопроцессорной и многозадачности, библиотека API ядра, пользовательская библиотека C, поддержка ELF, IPC (сообщения, сигналы, общая память, каналы), VFS, оконный сервер и графический интерфейс с самодельным набором инструментов, драйвер клавиатуры и мыши PS / 2, VESA видеодрайвер и многое другое…

Макс Шлюссель, lokoxe [at] gmail [dot] com

Открытый исходный код (GNU GPLv3)

http://ghostkernel.org/

Последний выпуск: 2018- 12-17, активный

GreenteaOS — это 64-битная настольная ОС для x86-64. Стремится к запуску файлов .exe изначально и стать альтернативой Windows с открытым исходным кодом. Следует собственному монолитному ядру, отличному от NT / UNIX.В настоящее время находится в стадии пре-альфа.

alegorium [at] gmail [dot] com

Открытый исходный код (GNU LGPLv3)

https://github.com/GreenteaOS

Активный

Haiku

Полнофункциональная операционная система с открытым исходным кодом, вдохновленная коммерческой операционной системой Be. Имеет вытесняющее модульное ядро, почти полную совместимость с POSIX, приятный (не на основе X11) графический интерфейс и широкий спектр портированных и собственных приложений (включая браузер на основе WebKit).Почти вся операционная система написана на C ++ 98 (включая ядро), хотя и с небольшим использованием исключений.

haiku-development [at] freelists.org

Открытый исходный код (MIT)

https://www.haiku-os.org/

Последний выпуск: 2019- 02-25, активен

HelenOS

Многосерверная архитектура с превентивным микроядром, поддержка SMP, облегченный IPC, локальное хранилище потоков и фибриллы, управляемые в пространстве пользователя.Наша домашняя страница: http://www.helenos.org/

helenos-devel [at] lists [dot] modry [dot] cz

Открытый исходный код (BSD / GPL)

https://github.com/HelenOS/helenos

Последняя фиксация: 2019-02-25, активен

HeliX

HeliX — немецкая ОС с открытым исходным кодом. Он имеет красивую оболочку и уже поддерживает FAT12, многозадачность, клавиатуру и мышь и многое другое… HeliX все еще находится в разработке и не существует давно, так что впереди еще много функций! [на] данный момент времени на веб-странице нет загрузок, потому что все еще есть серьезные ошибки (; -пожалуйста, будьте терпеливы; они появятся!

Illusoft, Ufo [at] sandrakoenig [точка] de

Открытый исходный код (BSD 2-clause)

https://github.com/Helix-OS/helix-os

Последняя фиксация: 15.01.2016, отменено

Hoho

Hoho — это ОС с открытым исходным кодом x86, поддерживающая многозадачность с исполняемыми файлами ELF, виртуальной памятью, FAT и виртуальной файловой системой, приводами ATA и гибкими дисками.Вскоре он будет размещен на собственном хостинге, а над ним будет работать GCC.

Дэвид, kingbabasula [at] gmail [dot] com

Открытый исходный код (Apache 2.0)

https://github.com/davidepianca98/hoho-os

Последний совершить: 2016-11-12, вероятно, отказался от

Водород

Hydrogen — это операционная система, предназначенная для встроенных систем (серверов, тонких клиентов, SBC), работающих на x86.Он написан на C и сборке (NASM). Поддержки VGA нет, только последовательный. Моя домашняя страница: http://moondeck.github.io/hydrogen

moondeck, olgierd [at] novakovsky [dot] eu

Открытый исходный код (Apache 2.0)

https://moondeck.github.io/hydrogen/

Последний коммит : 2017-06-01

JSD / OS

JSD / OS, что означает «Джейк С.Операционная система Del Mastro »или« Дисковая операционная система Джейка »- это крошечная псевдо-однозадачная операционная система для 32-битной архитектуры x86, которая постоянно разрабатывалась с 2014 года. Цель состоит в том, чтобы создать ОС с очень небольшим объемом памяти и быстрой файловой системой. и минимальные накладные расходы, позволяющие обрабатывать запросы пользователей как можно быстрее, что идеально подходит для интерактивных приложений, с использованием уникального планировщика, известного как CuFS (сознательно несправедливое планирование). Система может запускать приложения, упакованные в объектный формат ELF, и имеет полную поддержку памяти защита через виртуальные адресные пространства.Система включает оболочку, которая работает со многими командами DOS и Unix.

https://jakedelmastro.com/contact/

Открытый исходный код (BSD 3-Clause)

https://github.com/pgrAm/JSD-OS

Последний коммит: 2020-01-16

JSLK

JSLK — это 32-разрядное ядро ​​для любителей, разработанное для работы на архитектуре x86 (хотя переносимость была принята во внимание).Он был запущен в августе 2017 года с целью узнать, как работает компьютерная операционная система, и улучшить навыки программирования у основного разработчика. Ядро в основном написано на C с некоторыми частями сборки и частично совместимо с C ++ (предоставляется среда выполнения). Некоторые из его функций: обширный HAL API, совместимость с System V ABI, управление памятью, обработка прерываний, драйвер VGA, таймеры и задержки, некоторые примитивы синхронизации, растущая самодельная библиотека C, виртуальная память, VFS, клавиатура и RTC. водитель и многое другое.Сайт: https://sofferjacob.github.io/jslk.html

Jacobo Soffer, sofferjacob [at] gmail [dot] com

Открытый исходный код (GNU GPLv3)

https://github.com/sofferjacob/jslk

фиксация : 2018-12-21, активен

КЛИКА-ОС

Простая многозадачная ОС x86_64 с графическим интерфейсом. Имеет вытесняющую многозадачность, управление памятью, пользовательское пространство, FAT 12/14/16, графический интерфейс с VESA и т. Д.Написано на C и сборке.

Zaharije Pasalic, zaharije [at] klika [dot] ba

Открытый исходный код

https://github.com/klikaba/klika-os

Последняя фиксация: 2019 -11-27, активен

KnightOS

Операционная система с открытым исходным кодом для калькуляторов Texas Instruments. Функции вытесняющей многозадачности, управления памятью и т. Д.Написано на сборке z80. Зрелый SDK, удобное ядро, удобное пользовательское пространство, без математики. Наша домашняя страница: http://knightos.org

Дрю ДеВолт, сэр [at] cmpwn [dot] com

Открытый исходный код

https://github.com/KnightOS/KnightOS

Последняя фиксация: 01.01.2019 -28, активен

Колибри ОС

Kolibri OS была ответвлением 32-битной версии Menuet OS, но со временем сильно изменилась.Несмотря на то, что эта замечательная ОС умещается на стандартной дискете 1,44 МБ, она содержит: полный рабочий стол с графическим интерфейсом пользователя, множество драйверов и отличное программное обеспечение (например, веб-браузер и музыкальный проигрыватель), системные программы и игры! Ядро и большинство приложений, библиотек и драйверов написаны на FASM, но некоторые из них написаны на C— (https://en.wikipedia.org/wiki/C—; ссылка на их компилятор C—: http: // c—sphinx.narod.ru/). В этой ОС вы можете написать код ASM и выполнить его после сборки. Исходный код открыт — http: // websvn.kolibrios.org/listing.php?repname=Kolibri+OS — и вклады приветствуются!

Команда Kolibri OS

Открытый исходный код (GNU GPLv2)

http://www.kolibrios.org

Последняя фиксация: 22.02.2019, активна

Кора OS

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

Icon phone.png

.

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *