Добрый день/вечер/ночь/утро! Есть один экспериментальный курс по операционным системам. Есть он в Стэнфордском университете. Но часть материалов доступно всем желающим. Помимо слайдов доступны полные описания практических занятий.

Чем этот курс отличается от прочих других? Большая часть кода пишется самостоятельно и выполняется на вполне реальном современном железе. В качестве целевой платформы выбран Raspberry Pi 3 model B. Т.е. достаточно актуальная архитектура AArch64. ARMv8 Cortex-A53, четыре ядра, 64-бита и вот это всё. В качестве основного языка программирования выбран Rust. Который безопасный, быстрый, без GC и так далее. Его, Rust, предполагается изучать во время курса.

Тут есть про диски, файловые системы, операции ввода-вывода, потоки /процессы, планирование, виртуальную память, защиту и безопасность, прерывания, параллелизм и синхронизацию. Как и в любом другом, уважающем себя курсе. Разница в актуальности материала и в количестве практики. Коддить придётся много.

Примечание переводчика

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

Откуда я узнал про этот курс? Некто выложил ссылочку на Hacker News. Я случайно увидел и проникся. Немного сам тыкал материалы курса и в итоге решился это дело переводить.

Обзор

В этой части будем настраивать малинку и необходимые инструменты. По итогам у нас будет малинка, мигающая светодиодом. Тут есть четыре основных этапа. Для начала нам требуется убедиться, что связь Pi с компьютером вполне себе работает. Запустим предварительно подготовленную программу. Во втором этапе разберёмся, как светодиодики подключать. Про макетную плату и проводки. На третьем этапе соберём няшный сишный код и запустим его на Pi. Установим кросскомпилятор aarch64-none-elf и попробуем его в деле. И на четвёртом этапе перепишем это всё дело на Rust.

Парочка полезных ссылок:

• Документация по процессору BCM2837 — главным образом про периферию
• Красочная исчерпывающая статья про макетную плату и проводки
• Про использование GPIO в малинке
• Кратко про базовый синтаксис Rust для тех, кто и так неплохо программирует
• Оффициальный учебник по Rust на ангельском (русскоязычная версия ещё не готова — можно помочь с переводом)
• Rusty Types for Solid Safety
• Шпаргалка по лайфтаймам в Rust
• Шпаргалка по контейнерам в Rust (синий текст кликабелен)

Фаза 0: Начало работы

Перед выполнением курса следует достать себе в непосредственное пользование unix-подобную операционную систему. Это может быть Linux, BSD или macOS с установленными git, wget, tar, screen и make. Теоретически может заработать в Windows 10 с подсистемой linux, но никто не проверял наверняка. По крайней мере такая конфигурация не поддерживается. Т.е. для виндузятников нет готовых рецептов и рекомендуется установить Ubuntu LST или Fedora.

Из железа нам потребуются:

• Raspberry Pi 3 model B (обязательно с процем BCM2837)
• Макетная плата, она же доска для прототипирования
• microSD карточка (плюс адаптер/переходник)
• USB-UART переходник (CP2102 USB TTL)
• Десяток многоцветных светодиодов
• Резисторы на 100 Ом и на 1 кОм по четыре штуки
• проводки

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

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

Когда это всё есть в наличии можно стянуть код задания:

git clone https://web.stanford.edu/class/cs140e/assignments/0-blinky/skeleton.git 0-blinky
cd assignment0
make fetch

Не стесняйтесь исследовать содержимое самостоятельно.

Фаза 1: Готовим малинку

Первое, что нам требуется сделать — это настройка CP2102-переходника. Он нужен для общения между компьютером и Pi. По мимо этого малинка получает через него жизненно необходимые 5 вольт. С одной стороны USB, с другой штук пять штырьков, посередине платка.

Настройка драйверов

На линуксе всё должно заработать сразу из коробки. На маках потребуется установить драйвер. Скачиваем этот архив и распаковываем. Запускаем SiLabsUSBDriverDisk.dmg и соглашаемся с пунктами о продаже души по лицензии. После этого на подмонтированном томе запускаем Silicon Labs VPC Driver.pkg. Устанавливаем и перезагружаемся.

Попробуйте вставить CP2102 в свободный USB-слот. Если всё работает, то должны появится соответствующие файлы в /dev. В случае мака /dev/tty.SLAB_USBtoUART. В случае линукса что-то вроде /dev/ttyUSB0. Запишите — пригодится. Вынимаем переходник.

Подключение малинки

Теперь подключаем Raspberry Pi к CP2102. Вот таблица соответствия разъёмов:

Разъёмы на CP2102	Разъёмы на Raspberry Pi
+5v	4
GND	6
RXD	8
TXD	10

Нумерация пинов на малинке (ещё есть интерактивная версия):

Всё вместе будет выглядеть так (цвета проводов можно выбирать произвольно):

Важно: проверьте и перепроверьте соединения перед подключением этого всего к компьютеру. Нам нужна свежая малинка, а не подгоревшее варенье.

Если есть уверенность в правильности сопряжения малинки и переходника — можно таки подключить CP2102 к компу.

Запуск

Raspberry Pi подгружает программки с microSD-карточки во время включения. Прямо сейчас мы разберёмся, как это готовить.

Для начала нам нужно скинуть на microSD-шку файлики из склонированного репозитория. А именно те, которые лежат в папке files/firmware. Т.е. bootcode.bin, config.txt и start.elf. Скопировать их следует в корень флеш-карты. Если вдруг в склонированном репозитории нет этих файликов — вы забыли про make fetch.

Зачем нужны bootcode.bin, config.txt и start.elf?
Это всё является загрузчиком для малинки. bootcode.bin — первый загрузчик. Его задача — загрузить start.elf. Который настраивает процессор в соответствии с содержимым файла config.txt. После этого он загружает kernel8.img и передаёт ему управление. Кстати где он?

Теперь копируем files/activity-led-blink.bin из репо в корень флеш-карты и даём этому файлику имя kernel8.img. Размонтируем карту и вытаскиваем. Убеждаемся, что малинка отключена. Затем вставляем карточку в малинку и подключаем малинку к питанию. Мы должны увидеть мигающий светодиод на малинке и на CP2102-переходнике. Мигание последнего означает, что там передаются некие данные.

Данные? Какие данные? Для того, чтоб посмотреть их нам нужно подключить эмулятор последовательного терминала к CP2102 и прочитать, что там происходит. Будем использовать screen ибо он установлен и на Linux, и на macOS. Вспомните путь к устройству из папки /dev и запустите

screen /dev/<имя> 115200

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

sudo gpasswd --add <имя-пользователя> dialout

Так или иначе, но мы должны увидеть приветствия от малинки. Для выхода из screen следует нажать <ctrl-a> k, а затем ответить y на предложение о выходе.

Фаза 2: Мигаем светодиодом

На этом этапе мы подключим 16-й вывод GPIO (физический контакт №36) малинки к светодиодику на макетке. Проверим его работу используя предварительно подготовленный бинарник с прошивкой. Убедитесь что малинка отключена.

GPIO: General Purpose I/O (Ввод-вывод общего назначения)

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

GPIO-выводы на малинке могут работать как входы или как выходы. Когда контакт является выходным, его можно включить или выключить. Под включением контакта подразумевается, что с него можно взять 3.3 вольта. Под выключением подразумевается, что через этот контакт ток не идёт. Когда же GPIO-контакт является входным, то малинка проверяет, есть ли на оном 3.3 вольта, либо же нет.

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

Подключение светодиода.

Начнём с построения вот такой схемки:

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

Если всё заработало с равномерно горящим светодиодом, то можно попробовать оным помигать. Отрубаем малинку от питания. Теперь переподключаем светодиод от пина 1 к пину 36 (GPIO 16) вот таким образом:

Опять вынимаем карту памяти. Копируем на неё files/gpio16-blink.bin под именем kernel8.img вместо старого с тем же именем. Ставим карточку обратно и подключаем малинку к питанию. Теперь светодиод должен безудержно мигать.

Фаза 3: Няшный Си

На этот раз мы будем писать на сях прогу, которая будет делать тоже, что и gpio16-blink.bin. Для того, чтоб иметь возможность компилировать няшную сишечку под малинку нам нужен кросс-компилятор под aarch64-none-elf.

Установка кросс-компилятора

Нам нужно установить GNU-тулчейн для под архитектуру aarch64-none-elf (компилятор gcc и его компанию вроде objcopy).

Под macOS

Для начала стоит установить менеджер пакетов homebrew. Если уже установлен, то эту часть можно пропустить.

1. Установите инструменты Xcode для командной строки. Появится диалоговое окно. Когда появится — нажмите "Установить", "Продолжить" или что там обычно.
   

   xcode-select --install

2. Запустите скрипт установки Homebrew. Оный проведет вас через остальную часть процесса установки.
   

   /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"

Теперь установим тулчейн aarch64-none-elf используя homebrew.

brew tap SergioBenitez/osxct
brew install aarch64-none-elf

Проверим, всё ли правильно установлено:

$ aarch64-none-elf-gcc --version
aarch64-none-elf-gcc (GCC) 7.2.0
Copyright (C) 2017 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Под Linux

1. Загрузим и распакуем aarch64-none-elf-linux-x64.tar.gz. После этого переместим arch64-none-elf в /usr/local/bin:
   

   wget https://web.stanford.edu/class/cs140e/files/aarch64-none-elf-linux-x64.tar.gz
   tar -xzvf aarch64-none-elf-linux-x64.tar.gz
   sudo mv aarch64-none-elf /usr/local/bin

2. Добавим /usr/local/bin/aarch64-none-elf/bin к переменной окружения PATH. Как именно — это зависит от вашего конкретного диструбутива Linux. В большинстве случаев следует добавить в ~/.profile следующее:
   

   PATH="/usr/local/bin/aarch64-none-elf/bin:$PATH"

3. Проверяем, всё ли нормально. В качетве вывода мы должны получить версию gcc и всё такое.
   

   aarch64-none-elf-gcc --version

Можно собрать самому из исходников, если такое желание возникнет. Подробнее вот тут.

Теперь немного о железе

Взаимодействие подавляющего большинства современных аппаратных устройств с ПО осуществляется через отображение его в память Memory-mapped I/O. Суть такова: с устройствами можно общаться так, будто это просто некая часть памяти. При этом предоставляется спецификация о том, что будет происходить при записи или чтении определённых адресов в памяти. Адреса обычно разделяются на кусочки по 32 или 64 бита, которые называют регистрами. Регистры могут быть доступны только для чтения из них, для записи или для того и другого сразу.

Как мы узнаем, какие регистры и для чего использовать, и где в памяти они находятся? Производители различных устройств пишут документацию на эти самые устройства. Обычно их зовут даташитами (data sheet), мануалами (device manual), ну или просто документацией. Нет какого либо общего широко распространённого формата для документирования устройств. Иногда документация может быть недостаточной или её может не быть вообще. Умение читать и понимать аппаратную документацию это вполне себе полезный скилл и в некотором роде даже искусство.

Интерфейс GPIO в памяти

Документацию на многие периферийные устройства, которые есть у Rasbperry Pi, можно найти в документе BCM2837 ARM Peripherals Manual. Про GPIO можно почитать на 89 странице.

Падажжи, там же местами про BCM2835, а у нас BCM2837. Это норм?

Если открыть руководство, то там можно увидеть во многих местах упоминание BCM2835. Мы просто взяли руководство к нему и исправили некоторые ошибки. Ну и заголовок поменяли на BCM2837. BCM2837 и BCM2835 имеют одинаковые периферийные устройства с теми же относительными адресами в памяти. Основное отличие в общей конфигурации физической памяти. Базовый физический адрес периферийных устройств на BCM2837 — 0x3F000000, в отличии от 0x20000000 в BCM2835. Однако оба чипа отображают эти адреса на 0x7E000000. Вкратце на BCM2837 "периферийный" адрес 0x7EXXXXXX будет находится на физическом адресе 0x3FXXXXXX. Приведённая документация изменена с учётом этого.

Для нашей задачи нам достаточно следующих регистров:

имя	адрес	описание	размер	чтение/запись
GPFSEL1	0x7E200004	GPIO Function Select 1	32 бита	и то и другое
GPSET0	0x7E20001C	GPIO Pin Output Set 0	32 бита	только запись
GPCLR0	0x7E200028	GPIO Pin Output Clear 0	32 бита	только запись

Тащемто это непосредственно скопировано прямо из документации со страницы 90.

Теперь почитайте документацию для регистра GPFSELn на страницах 91 и 92. Мы записываем в этот регистр для настройки пинов в качестве выходных или входных. Какое должно быть значение в каждом поле регистра GPFSEL1 для настройки вывода №16 GPIO, чтоб он стал выходом?

Теперь опять читаем документацию на странице 95. Про регистры GPSET0 и GPCLR0. Мы записываем в регистр GPSET0 для включения контакта. А в GPCLR0 для выключения. Какое значение нам требуется записать в эти регистры для включения/выключения вывода 16?

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

В каталоге phase3/ репы есть заготовка кода для построения двоичного файла для малинки. Пока обойдёмся без объяснения того, зачем нужны crt0.S, layout.ld и Makefile. Вместо этого сосредоточимся на blinky.c. В нём вы обнаружите, что уже указаны адреса всех трёх необходимых нам регистров в верхней части. Кроме этого там есть парочка функций, которыми можно создать временную задержку. Задача состоит в том, чтоб дополнить функцию main так, чтобы вывод №16 GPIO был настроен как выход, а затем то включался, то выключался для мигания светодиодом.

Когда код будет готов — его следует протестировать. Для начала скомпилируйте его, запустив make, находясь в директории phase3/. Если всё хорошо и нет ошибок, то создастся файлик blinky.bin. Переименовываем его в kernel8.img, копируем на microSD-карточку и запускаем это всё на малинке. Если уже есть работающий kernel8.img — можно переходить к следующей фазе.

Подсказки:

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

Тут пригодятся операторы <<, |, & и ~.

В сишечке можно использовать шестнадцатеричную и двоичную формы. Для числа три что-то вроде 0x03 и 0b011 соответственно.

Фаза 4: Ржавчина

В этот раз мы будем писать программу, подобную gpio16-blink.bin, но уже на Rust. Код пишем в phase4/src/lib.rs.

Установка Rust и Xargo

Для того, чтоб компилять программы на Rust, нам следует этот самый компейлятор установить. Помимо этого мы установим xargo, который является обёрткой, связанной с менеджером пакетов cargo. Xargo позволяет нам компейлировать наш код для Rasbperry Pi и всего такого.

1. Идём на https://rustup.rs/ и следуем инструкциям для установки rustup. Убедитесь, что Rust был установлен корректно, запустив rustc --version.
2. Теперь используем rustup и cargo (который установился вместе с rustc на прошлом шаге) для установки ночной сборки Rust. Заодно и исходники стандартной библиотеки установим. И xargo разумеется.
   

   rustup default nightly-2018-01-09
   rustup component add rust-src
   cargo install xargo

3. Проверяем установленные команды и убеждаемся, что версии всего этого соответствуют тому, чего мы от них хотим:
   

   $ rustc --version
   rustc 1.25.0-nightly (b5392f545 2018-01-08)
   $ xargo --version
   xargo 0.3.10
   cargo 0.25.0-nightly (a88fbace4 2017-12-29)

Теперь у нас есть вполне себе рабочий компилятор Rust.

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

Для написания кода в файле phase4/src/lib.rs нужно знать по крайней мере следующие конструкции:

1) Вы можете читать из и писать в то, что находится за голыми указателями (*mut T) при помощи методов read_volatile() и write_volatile(). Например у нас объявлено такое:

const A: *mut u32 = 0x12 as *mut u32;
const B: *mut u32 = 0x34 as *mut u32;

Мы можем записать 32-разрядное целое число без знака с адресом 0x12 в ячейку с адресом 0x34 примерно вот так:

B.write_volatile(A.read_volatile());

2) Локальные переменные обявляются при помощи конструкции let имя_переменной = некое_выражение;.
Можно прочитать A из предыдущего примера (т.е. значение, расположенное по адресу 0x12) в переменную вот таким образом:

let value = A.read_volatile();

3) Вызвать функцию fn f(param: usize); можно вот так: f(123);.
4) Блок loop можно использовать для бесконечного повторения чего либо:

loop {
    do_this_again_and_again();
}

5) В Rust есть следующие побитовые операторы:

• ! — инверсия
• << — сдвиг влево
• >> — сдвиг вправо
• | — битовое ИЛИ
• & — битовый И.

Теперь вы готовы помигать светодиодом из кода на Rust. Код пишем в phase4/src/lib.rs. Переведите сишный код в аналогичный rust-код (в функции kmain). Тут уже объявлены необходимые регистры и функция "сна", которая создаёт задержку на некоторое время. Используйте это всё.

Когда будете готовы проверить свою прогу, скомпилируйте её, запустив make в каталоге phase4. Если всё нормально, то создастся файл build/blinky.bin, который переименовываем в kernel8.img и кладём на microSD-карточку, которую затем вставляем в малинку. Когда светодиодик снова замигает — можно считать, что данная часть туториала завершена.