Arm linux gnueabihf fedora

Заводим GNU/Linux на ARM-плате с нуля (на примере Kali и iMX.6)

tl;dr: собираю образ Kali Linux для ARM-компьютера, в программе debootstrap , linux и u-boot .

Если вы покупали какой-нибудь не очень популярный одноплатник, то могли столкнуться с отсутствием для него образа любимого дистрибутива. Приблизительно то же самое случилось с планируемым Flipper One. Kali Linux под IMX6 просто нету (я готовлю), поэтому собирать приходится самостоятельно.

Процесс загрузки достаточно простой:

1. Инициализируется железо.
2. Из некоторой области на запоминающем устройства (SD-карта/eMMC/etc) считывается и выполняется загрузчик.
3. Загрузчик ищет ядро операционной системы и загружает его в некоторую область памяти и выполняет.
4. Ядро загружает всю остальную ОС.

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

Сборка корневой файловой системы

Для начала нужно подготовить разделы. Das U-Boot поддерживает разные ФС, я выбрал FAT32 для /boot и ext3 для корня, это стандартная разметка образов для Kali под ARM. Я воспользуюсь GNU Parted, но вы можете сделать то же самое более привычным fdisk . Также понадобятся dosfstools и e2fsprogs для создания ФС: apt install parted dosfstools e2fsprogs .

1. Отмечаем SD-карту как использующую MBR-разметку: parted -s /dev/mmcblk0 mklabel msdos
2. Создаём раздел под /boot на 128 мегабайт: parted -s /dev/mmcblk0 mkpart primary fat32 1MiB 128MiB . Первый пропущенный мегабайт необходимо оставить под саму разметку и под загрузчик.
3. Создаём корневую ФС на всю оставшуюся ёмкость: parted -s /dev/mmcblk0 mkpart primary ext4 128MiB 100%
4. Если вдруг у вас не создались или не изменились файлы разделов, надо выполнить `partprobe`, тогда таблица разделов будет перечитана.
5. Создаём файловую систему загрузочного раздела с меткой BOOT : mkfs.vfat -n BOOT -F 32 -v /dev/mmcblk0p1
6. Создаём корневую ФС с меткой ROOTFS : mkfs.ext3 -L ROOTFS /dev/mmcblk0p2

Отлично, теперь можно её заполнять. Для этого дополнительно потребуется debootstrap , утилита для создания корневых ФС Debian-подобных операционных систем: apt install debootstrap .

1. Монтируем раздел в /mnt/ (используйте более удобную для себя точку монтирования): mount /dev/mmcblk0p2 /mnt
2. Собственно заполняем файловую систему: debootstrap —foreign —include=qemu-user-static —arch armhf kali-rolling /mnt/ http://http.kali.org/kali . Параметр —include указывает дополнительно установить некоторые пакеты, я указал статически собранный эмулятор QEMU. Он позволяет выполнять chroot в ARM-окружение. Смысл остальных опций можно посмотреть в man debootstrap . Не забудьте, что не любая ARM-плата поддерживает архитектуру armhf .
3. Из-за разницы архитектур debootstrap выполняется в два этапа, второй выполняется так: chroot /mnt/ /debootstrap/debootstrap —second-stage
4. Теперь нужно зачрутиться: chroot /mnt /bin/bash
5. Заполняем /etc/hosts и /etc/hostname целевой ФС. Заполните по аналогии с содержимым на вашем локальном компьютере, не забудьте только заменить имя хоста.
6. Можно донастроить всё остальное. В частности я доустанавливаю locales (ключи репозитория), перенастраиваю локали и часовой пояс ( dpkg-reconfigure locales tzdata ). Не забудьте задать пароль командой passwd .
7. Задаём пароль для root командой passwd .
8. Приготовления образа для меня завершаются заполнением /etc/fstab внутри /mnt/ .

Загружать буду в соответствии с созданными ранее метками, поэтому содержимое будет таким:

LABEL=ROOTFS / auto errors=remount-ro 0 1
LABEL=BOOT /boot auto defaults 0 0

Наконец, можно примонтировать загрузочный раздел, он нам понадобится для ядра: `mount /dev/mmcblk0p1 /mnt/boot/`

Сборка Linux

Для сборки ядра (и загрузчика потом) на Debian Testing надо установить стандартный набор из GCC, GNU Make и заголовочных файлов GNU C Library для целевой архитектуры (у меня armhf ), а также заголовки OpenSSL, консольный калькулятор bc , bison и flex : apt install crossbuild-essential-armhf bison flex libssl-dev bc . Так как загрузчик по умолчанию ищет файл zImage на файловой системе загрузочного раздела, пора разбивать флешку.

1. Клонировать ядро слишком долго, поэтому просто скачаю: wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.9.1.tar.xz . Распакуем и перейдём в директорию с исходниками: tar -xf linux-5.9.1.tar.xz && cd linux-5.9.1
2. Конфигурируем перед компиляцией: make ARCH=arm KBUILD_DEFCONFIG=imx_v6_v7_defconfig defconfig . Конфиг находится в директории arch/arm/configs/ . Если такового нет, вы можете попробовать найти и скачать готовый и передать название файла в этой директории в параметр KBUILD_DEFCONFIG . В крайнем случае сразу переходите к следующему пункту.
3. Опционально можно докрутить настройки: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf- menuconfig
4. И кроскомпилируем образ: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabihf-
5. Теперь можно скопировать файлик с ядром: cp arch/arm/boot/zImage /mnt/boot/
6. И файлы с DeviceTree (описание имеющегося на плате железа): cp arch/arm/boot/dts/*.dtb /mnt/boot/
7. И доустановить собранные в виде отдельных файлов модули: make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- INSTALL_MOD_PATH=/mnt/ modules_install

Ядро готово. Можно всё отмонтировать: umount /mnt/boot/ /mnt/

Das U-Boot

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

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

Cобираем сам загрузчик:

1. Клонируем стабильную ветку репозитория: git clone https://gitlab.denx.de/u-boot/u-boot.git -b v2020.10
2. Переходим в саму директорию: cd u-boot
3. Готовим конфигурацию сборки: make mx6ull_14x14_evk_defconfig . Это работает только если конфигурация есть в самом Das U-Boot, в ином случае вам потребуется найти конфиг производителя и положить его в корень репозитория в файл .config , или собрать иным рекомендованным производителем образом.
4. Собираем сам образ загрузчика кросс-компилятором armhf : make CROSS_COMPILE=arm-linux-gnueabihf- u-boot.imx

В результате мы получаем файл u-boot.imx , это готовый образ, который можно записывать на флешку. Записываем на SD-карту, пропустив первые 1024 байта. Почему я выбрал таргет u-boot.imx ? Почему пропустил именно 1024 байта? Так предлагают сделать в документации. Для других плат процесс сборки образа и записи может немного отличаться.

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

Вместо заключения

А вы знали, что лоб у дельфина не костистый? Это буквально третий глаз, жировая линза для эхолокации!

Источник

Кросскомпиляция под ARM

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

В данном посте будут описаны:

1. Инструменты
2. Элементарная технология кросскомпиляции
3. И, собственно, HOW2

Кому это интересно, прошу под кат.

Вводная

Одно из развивающихся направлений в современном IT это IoT. Развивается это направление достаточно быстро, всё время выходят всякие крутые штуки (типа кроссовок со встроенным трекером или кроссовки, которые могут указывать направление, куда идти (специально для слепых людей)). Основная масса этих устройств представляют собой что-то типа «блютуз лампочки», но оставшаяся часть являет собой сложные процессорные системы, которые собирают данные и управляют этим огромным разнообразием всяких умных штучек. Эти сложные системы, как правило, представляют собой одноплатные компьютеры, такие как Raspberry Pi, Odroid, Orange Pi и т.п. На них запускается Linux и пишется прикладной софт. В основном, используют скриптовые языки и Java. Но бывают приложения, когда необходима высокая производительность, и здесь, естественно, требуются C и C++. К примеру, может потребоваться добавить что-то специфичное в ядро или, как можно быстрее, высчитать БПФ. Вот тут-то и нужна кросскомпиляция.

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

Поэтому лучше собирать на хосте. В моём случае, это i5 с 4ГБ ОЗУ, Fedora 24.

Инструменты

Для кросскомпиляции под ARM требуются toolchain и эмулятор платформы либо реальная целевая платформа.

Т.к. меня интересует компиляция для ARM, то использоваться будет и соответствующий toolchain.

Toolchain’ы делятся на несколько типов или триплетов. Триплет обычно состоит из трёх частей: целевой процессор, vendor и OS, vendor зачастую опускается.

• *-none-eabi — это toolchain для компиляции проекта работающего в bare metal.
• *eabi — это toolchain для компиляции проекта работающего в какой-либо ОС. В моём случае, это Linux.
• *eabihf — это почти то же самое, что и eabi, с разницей в реализации ABI вызова функций с плавающей точкой. hf — расшифровывается как hard float.

Описанное выше справедливо для gcc и сделанных на его базе toolchain’ах.

Сперва я пытался использовать toolchain’ы, которые лежат в репах Fedora 24. Но был неприятно удивлён этим:

Поискав, наткнулся на toolchain от компании Linaro. И он меня вполне устроил.

Второй инструмент- это QEMU. Я буду использовать его, т.к. мой Odroid-C1+ пал смертью храбрых (нагнулся контроллер SD карты). Но я таки успел с ним чуток поработать, что не может не радовать.

Элементарная технология кросскомпиляции

Собственно, ничего необычного в этом нет. Просто используется toolchain в роли компилятора. А стандартные библиотеки поставляются вместе с toolchain’ом.

Выглядит это так:

Какие ключи у toolchain’а можно посмотреть на сайте gnu, в соответствующем разделе.

Для начала нужно запустить эмуляцию с интересующей платформой. Я решил съэмулировать Cortex-A9.

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

Ну сперва, само собою, нужно заиметь QEMU. Установил я его из стандартных репов Fedor’ы.

Далее создаём образ жёсткого диска, на который будет установлен Debian.

По этой ссылке скачал vmlinuz и initrd и запустил их в эмуляции.

Далее просто устанавливаем Debian на наш образ жёсткого диска (у меня ушло

После установки нужно вынуть из образа жёсткого диска vmlinuz и initrd. Делал я это по описанию отсюда.

Сперва узнаём смещение, где расположен раздел с нужными нам файлами:

Теперь по этому смещению примонтируем нужный нам раздел.

Копируем файлы vmlinuz и initrd и размонтируем жёсткий диск.

Теперь можно запустить эмуляцию.

И вот заветное приглашение:

Теперь с хоста по SSH можно подцепиться к симуляции.

Теперь можно и собрать программку. По Makefile’у ясно, что будет калькулятор. Простенький.

Собираем на хосте исполняемый файл.

Отмечу, что проще собрать с ключом -static, если нет особого желания предаваться плотским утехам с библиотеками на целевой платформе.

Копируем исполняемый файл на таргет и проверяем.

Собственно, вот такая она, эта кросскомпиляция.

UPD: Подправил информацию по toolchain’ам по комментарию grossws.

Источник

Русские Блоги

Среда кросс-компиляции ARM-LINUX

В связи с необходимостью разработки приложений для руки необходимо создать среду компиляции для руки. Есть два способа создать среду:

• Среда кросс-компиляции
• среда разработки руки

Среда кросс-компиляции включает следующее:

• Используйте Visual Studio для создания среды разработки под Windows
• Используйте GCC для создания среды разработки под Linux

Поскольку среда Linux более удобна в настройке, рекомендуется использовать среду Linux для разработки. Visual Studio удобнее разрабатывать, IDE лучше, но удобнее выбирать Linux + Makefile.

Построение среды Linux

Так называемая настройка среды заключается в установке ряда инструментов для компиляции и отладки.Установленный здесь инструмент — am-linux-gcc.

Объяснение названия инструментария

gcc — это инструмент компиляции для x86-64, который может компилировать наборы инструкций, такие как SSE и AVX. Целевое оборудование — это ЦП настольного уровня. А gcc-arm-linux — это программное обеспечение, которое работает на ЦП настольного уровня. Созданный исполняемый файл — это файл, который запускается на руке.

Что такое аби и эаби

• ABI: двоичный интерфейс приложения (ABI) для архитектуры ARM
  В компьютере двоичный интерфейс приложения описывает низкоуровневый интерфейс между приложением (или другими типами) и операционной системой или другими приложениями.
• ABI охватывает различные детали, например:
  • Размер, расположение и выравнивание типов данных;
  • Соглашение о вызовах (контролирует, как передаются параметры функции и как принимается возвращаемое значение), например, все параметры передаются через стек или некоторые параметры передаются через регистры; какой регистр используется для какого параметра функции; первый передается через стек Параметр функции помещается в стек первым или последним;
  • Кодирование системных вызовов и то, как приложение выполняет системные вызовы операционной системы;
  • А в полной операционной системе ABI — двоичный формат объектного файла, программной библиотеки и т. Д.

Полный ABI, такой как Intel Binary Compatibility Standard (iBCS), позволяет программам в операционных системах, которые его поддерживают, запускаться в других операционных системах, поддерживающих этот ABI, без изменений.
ABI отличается от интерфейса прикладного программирования (API), API определяет интерфейс между исходным кодом и библиотекой, поэтому один и тот же код может быть скомпилирован в любой системе, поддерживающей этот API, ABI позволяет компиляцию Хороший целевой код может работать без изменений в системе, использующей ABI-совместимую.

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

Основное различие между EABI и ABI на компьютерах общего назначения заключается в том, что привилегированные инструкции разрешены в коде приложения, динамическое связывание не требуется (иногда запрещено), а для экономии памяти используется более компактная структура стека. EABI широко используется Power PC и ARM.

Два кросс-компилятора, связанные с gnueabi: gnueabi и gnueabihf

Определения этих двух кросс-компиляторов в исходном коде debian следующие:

• gcc-arm-linux-gnueabi – The GNU C compiler for armel architecture
• gcc-arm-linux-gnueabihf – The GNU C compiler for armhf architecture

Видно, что эти два кросс-компилятора подходят для двух разных архитектур armel и armhf. Две архитектуры armel и armhf используют разные стратегии для операций с плавающей запятой (руки с fpu могут поддерживать эти две стратегии операций с плавающей запятой)

Фактически, эти два кросс-компилятора представляют собой просто параметры gcc -mfloat-abi с разными значениями по умолчанию. Параметр gcc -mfloat-abi имеет три значения soft, softfp и hard (последние два требуют плавающей запятой fpu в руке) Операционный блок, soft и два последних совместимы, но два режима softfp и hard несовместимы друг с другом):

• soft: не используйте fpu для вычислений с плавающей запятой, даже если есть арифметический блок fpu с плавающей запятой, не используйте его, а используйте программный режим.
• softfp: значение по умолчанию, используемое архитектурой armel (соответствующий компилятор — gcc-arm-linux-gnueabi), вычисляется fpu, но параметры передаются обычными регистрами, поэтому при прерывании нужно сохранять только обычные регистры, а нагрузка прерывания мала. Но параметры нужно преобразовать в числа с плавающей запятой, а затем рассчитать.
• hard: значение по умолчанию, используемое архитектурой armhf (соответствующий компилятор gcc-arm-linux-gnueabihf), вычисляется fpu, а параметры также передаются регистром с плавающей запятой в fpu, что сохраняет преобразование. Производительность самая лучшая, но прерывание загрузки высоко.

Жесткое плавание

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

Мягкий поплавок

Компилятор преобразует операции с плавающей запятой в вызовы арифметических функций с плавающей запятой и вызовы библиотечных функций.Нет вызова инструкций FPU и передачи параметров регистра с плавающей запятой. Передача параметров с плавающей запятой также осуществляется через регистры или стеки ARM.
Текущая система Linux предпочитает использовать по умолчанию для компиляции жесткое с плавающей запятой, даже если в системе нет процессора с плавающей запятой, это приведет к возникновению недопустимых инструкций и исключений. Поэтому в общих системных образах используется мягкая плавающая точка для совместимости с процессорами без VFP.

armel ABI и armhf ABI

В armel есть три соглашения для вычислений с плавающей запятой. Взяв в качестве примера gcc, есть три соответствующих значения параметра -mfloat-abi: soft, softfp и hard.

• Soft означает, что все операции с плавающей запятой реализуются на программном уровне. Конечно, эффективность невысока. Будут ненужные преобразования из чисел с плавающей запятой в целые числа и из целых чисел в числа с плавающей запятой. Это подходит только для ранних процессоров ARM без вычислительных блоков с плавающей запятой;
• Softfp в настоящее время является настройкой armel по умолчанию. Он передает вычисления с плавающей запятой в FPU для обработки, но для передачи параметров функции используются общие целочисленные регистры вместо регистров FPU;
• Hard использует регистры с плавающей запятой FPU для передачи параметров функции в FPU для обработки.

Следует отметить, что с точки зрения совместимости soft и два последних совместимы, но два режима softfp и hard несовместимы.

• По умолчанию armel использует softfp, поэтому armel в жестком режиме используется только как abi, называемый armhf.
  В жестком режиме каждый раз при вызове функций, связанных с плавающей запятой, можно сохранить в среднем 20 циклов ЦП. Для архитектуры, которая важна для каждого цикла, такой как ARM, это улучшение, несомненно, огромно.
• В некоторых приложениях без изменения исходного кода и конфигурации использование armhf может улучшить производительность на 20-25%. Для некоторых программ, которые в значительной степени полагаются на операции с плавающей запятой, можно добиться повышения производительности на 300%.

Источник