Ubuntu сборка ядра
Как собрать ядро linux? Сборка ядра Linux
Сборка ядра Linux
Здравствуйте, уважаемые читатели. Сегодня я расскажу о таком интересном занятии как сборка ядра Linux. Зачем может понадобиться самостоятельно собирать ядро? На самом деле причин может быть множество: необходимость задействовать дополнительные возможности ядра, оптимизировать ядро под ваш компьютер, обновить ядро до самой свежей версии. В этой статье я продемонстрирую процесс получения исходных кодов, настройки, компиляции и установки в систему ядра Linux, в рамках решения задачи включения в ядро поддержки cryptoloop(петлевые шифрующие устройства).
Получение исходного кода
В первую очередь мы должны получить исходный код, это можно сделать разными способами и из разных источников. Я предлагаю рассмотреть только два: системные репозитории, официальный сайт ядра. В репозиториях, скорее всего, будут версии ядра более старые чем он официальном сайте, но в эти исходники должны быть включены патчи и исправления от производителя вашего дистрибутива Linux. Такой подход предпочтительнее если вы не нуждаетесь в какой-то новой технологии или возможности, которая поддерживается только более новыми ядрами. Просмотреть все версии исходников ядра, которые содержатся в репозиториях вашей системы, вы можете введя в терминале(справедливо для Ubuntu Linux, в других дистрибутивах название пакета может отличаться):
apt-cache search linux-source
Команда выведет список доступных пакетов:
Как видите, у меня есть только пакет с текущей версией и пакет с версией 3.5 (на самом деле текущая версия ядра тоже 3.5). Расширить список ядер, доступных таким образом, стоит подключить дополнительные репозитории. Получить ядро мы можем командой:
sudo apt-get install linux-source
linux-source — имя пакета с исходным кодом, в вашем случае может быть другим.
После завершения работы команды в директории /usr/src появится файл, в моем случае — linux-source-3.5.0.tar.bz2. Перейдем в папку, распакуем архив и ради удобства создадим символическую ссылку:
cd /usr/src sudo tar -xjvf linux-source-3.5.0.tar.bz2 sudo ln -s linux-source-3.5.0 linux
Если же вам нужна самая свежая версия ядра, то её всегда можно скачать с сайта kernel.org. Стоит заметить, что на сайте выкладываются как стабильные версии ядер так и версии предназначенные для тестирования и доработки(обычно в их названии есть содержится аббревиатура «RC» — Release candidate). Если вы не желаете лишних проблем с системой, советую скачивать стабильную версию:
Сохраним архив с исходниками в папку /usr/src. Чтобы распаковать полученный архив вам может понадобиться установить дополнительные утилиты:
sudo apt-get install xz-utils
Теперь, как и в случае с загрузкой ядра из репозиториев, мы должны распаковать архив с исходниками и создать ссылку:
cd /usr/src sudo tar -xpJf linux-3.8.5.tar.xz sudo ln -s linux-3.8.5.tar.xz linux
Конфигурация и компиляция.
Вот мы и подошли к самому интересному. Прежде чем начать, установим несколько дополнительных пакетов:
sudo apt-get install build-essential kernel-package libncurses-dev
Будем создавать новую конфигурацию, на основе используемого системой в данный момент ядра:
cd /usr/src/linux sudo make oldconfig
Если вы конфигурируете более новую версию ядра чем есть в системе, то вполне вероятно что в ней появились параметры, которых нет в конфигурации нынешнего ядра. В таком случае программа будет просит сделать выбор вас, вы можете оставлять значения по умолчанию просто нажимая клавишу Enter. В любом случае конфигурирование ещё не завершено. Теперь мы можем выполнить нужные нам настройки через меню создания конфигурации:
sudo make menuconfig
В терминале запустится программа конфигурирования:
Здесь параметры конфигурации разделены на разделы, чтобы в них было удобнее ориентироваться. Как я уже говорил выше, мне нужно включить в ядро поддержку cryptoloop. Для этого нужно перейти в раздел «Device Drivers», а из него в подраздел «Block Devices»:
Находим параметр «Cryptoloop Support», рядом с ним стоит буква «М» что означает что поддержка шифрующих устройств будет добавлена как модуль ядра, который можно будет включить командой modprobe. Нам же надо включить поддержку данной технологии непосредственно в ядро, чтобы она поддерживалась всегда. Переводим фокус на параметр «Cryptoloop Support» и нажимаем на пробел. Буква «М» должна смениться символом "*" это означает что поддержка данной технологии будет «вшита» в ядро. Осторожно, пробел означает что технология вообще поддерживаться не будет.
Нажимаем клавишу «Tab» и нажимаем на кнопку «Exit» до тех пор пока не появится запрос на сохранение изменений:
Отвечаем «Yes». Мы успешно закончили конфигурирование!Приступим к компиляции. Сначала удаляем файлы оставшиеся от предыдущих сборок, если вы запускаете сборку впервые выполнять эту команду не обязательно:
sudo make-kpkg clean
Запускаем компиляцию:
sudo make-kpkg -j4 --initrd --append-to-version=-mykernel kernel_image kernel_headers
-j4 — флаг, указывает какое количество потоков использовать для компиляции. Позволит сильно ускорить компиляцию на многоядерных процессорах. Цифра 4 тут указывает на 4 потока. Ставьте столько потоков сколько ядер вашего процессора «видит» система.
-mykernel — префикс указывающий что ядро было собрано вручную, можете его изменить, фактически ни на что не влияет.
Вот и начался процесс компиляции. Он может занять от 10 минут, до нескольких часов в зависимости от того насколько мощный у вас компьютер:
Установка ядра в системуПосле завершения компиляции, в директории /usr/src должны появится два файла с расширением «deb» они являются установочными пакетами нашего нового ядра и установить их можно с помощью утилиты dpkg:
sudo dpkg -i linux-image-3.8.5-mykernel_3.8.5-mykernel-10.00.Custom_i386.deb
sudo dpkg -i linux-headers-3.8.5-mykernel_3.8.5-mykernel-10.00.Custom_i386.deb
Поздравляю! Ядро установлено, теперь система будет загружаться с этим ядром по умолчанию, но если у вас возникнут проблемы с новым ядром вы всегда можете загрузится со старым выбрав его на экране загрузки — Grub. На этом я завершаю сегодняшнюю статью и желаю успехов, вам, уважаемые читатели!
Вебинар: «Конфигурирование, сборка и установка ядра Linux»
Конфигурирование, сборка и установка ядра Linux
Главная > Специалист-ТВ
Операционная система Linux завоевала огромную популярность во всем мире, благодаря свободному распространению и возможности доработки пользователем под собственные нужды. Однако для того чтобы оценить работу на данной операционной системе и уметь настраивать ее с учетом своих потребностей, необходимо получить специальные знания.
Причины, по которым может возникнуть необходимость в сборке ядра системы. В каких случаях это необходимо делать обязательно.
1) Получение исходных кодов ядра. Версии. Развёртывание файлового дерева исходных кодов.
2) Сбор информации о системе, для которой предназначено ядро.
3) Конфигурирование ядра из начальной конфигурации "в состоянии поставки", и используя в качестве основы гарантированно рабочую конфигурацию предыдущей версии.
4) Модули, модульная архитектура ядра Linux.
5) Компиляция и сборка ядра.
6) Установка нового ядра автоматически и "вручную".
7) Конфигурирование начального загрузчика для использования нового ядра.
8) Рестарт системы под управление нового ядра. Проверка работоспособности.
Дата
с 19.06.2022
по 03.07.2022
Режим обучения
воскресенье утро-день
10:00 — 17:10
Очно и онлайн
Курс
Linux. Уровень 2. Администрирование сервисов и сетей.
Преподаватель
СорокинВладимир
Евгеньевич
Место обучения
"Радио"
м.Бауманская
м.Авиамоторная
Стоимость для физ. лиц
Дата
с 20.06.2022
по 22.06.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Linux. Уровень 3. Обеспечение безопасности систем, сервисов и сетей
Преподаватель
СоколовМихаил
Юрьевич
Место обучения
"Белорусско-Савеловский"
м.Белорусская
м.Савеловская
Стоимость для физ. лиц
Дата
с 20.06.2022
по 22.06.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Linux. Уровень 4. Интеграция с корпоративными решениями Microsoft
Преподаватель
СоколовМихаил
Юрьевич
Место обучения
"Белорусско-Савеловский"
м.Белорусская
м.Савеловская
Стоимость для физ. лиц
Дата
с 22.06.2022
по 24.06.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Linux. Уровень 6. Создание отказоустойчивых кластерных решений
Преподаватель
ЛохтуровВячеслав
Александрович
Место обучения
"Радио"
м.Бауманская
м.Авиамоторная
В группе осталось 4 места.
Успейте записаться на свободные места!
Стоимость для физ. лиц
Дата
с 22.06.2022
по 24.06.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Linux. Уровень 7. Мониторинг оборудования и интеграция с решениями Cisco
Преподаватель
ЛохтуровВячеслав
Александрович
Место обучения
"Радио"
м.Бауманская
м.Авиамоторная
В группе осталось 4 места.
Успейте записаться на свободные места!
Стоимость для физ. лиц
Дата
с 29.06.2022
по 01.07.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Очно и онлайн
Курс
Linux. Уровень 1. Основы администрирования системы
Преподаватель
МонаховПавел
Сергеевич
Место обучения
"Радио"
м.Бауманская
м.Авиамоторная
В группе осталось 5 мест.
Успейте записаться на свободные места!
Стоимость для физ. лиц
Дата
с 25.07.2022
по 28.07.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Linux (Ubuntu). Уровень 2. Программирование в Linux на C
Преподаватель
СедыхИгорь
Вячеславович
Место обучения
"Таганский"
м.Пролетарская
м.Крестьянская застава
Стоимость для физ. лиц
Дата
с 25.07.2022
по 29.07.2022
Режим обучения
ежедневно утро-день
10:00 — 17:10
Открытое обучение
Очно и онлайн
Курс
Разработка драйверов устройств в Linux
Преподаватель
СедыхИгорь
Вячеславович
Место обучения
"Таганский"
м.Пролетарская
м.Крестьянская застава
Стоимость для физ. лиц
Заказ добавлен в Корзину.
Для завершения оформления, пожалуйста, перейдите в Корзину!
Поделитесь с друзьями!
Главная > Специалист-ТВ
Пошаговая инструкция по сборке ядра под nethunter
$ git clone https://android.googlesource.com/platform/prebuilts/gcc/linux-x86/arm/arm-eabi-4.8
Далее нужны исходники самого ядра.
На этом примере исходники кастомного ядра уже с поддержкой hid (для уменьшения времени поиска)
Для удобства создать отдельную папку для всего этого дела и перенести исходники и тулчейн в нее.
Создали, перенесли, заходите в нее и следом сразу в исходники.
Там увидите много много файлов и папок, открывайте терминал в этой папке (правой кнопкой мыши на пустом месте и далее в контекстном меню выбрать "открыть терминал").
Открыли и тут начинается вся работа.
Прописать комманды:
$ export ARCH=arm64 #это покажет установщику что мы используем настройки для arm64
Для arm:
$ export ARCH=arm
Далее нам нужно указать путь до тулчейна, в моем случае я писал:
$ export CROSS_COMPILE=~/kernel/aarch64-linux-android-4.9/bin/aarch64-linux-android-
Обязательно с тире!
(для arm и arm64 просто пишем путь до файла(все также)(~/ озночает домашнюю папку)
Далее
$ export TARGET=out #чтобы все файлы сохранялись в папке out которую надо создать предварительно
Все делается в папке с исходниками
Пишем
$ make help #это отобразит все профили настроек которые уже есть.(все в первоначальной папке!
Будет много много текста, просто крутим вниз пока не увидим строчки с _defconfig.(это и есть файлы конфигурации)
Лично мне нужна это конфигурация:
Пишем
$ make vince_defconfig
Конфиг успешно записан.
Далее нам нужен патч aircrack. качаем его:
$ wget https://patches.aircrack-ng.org/mac80211.compat08082009.wl_frag+ack_v1.patch
И вставляем его командой:
$ patch -p1 < mac80211.compat08082009.wl_frag+ack_v1.patch
Теперь нам надо настроить ядро.
Пишем
$ make menuconfig #чтобы войти в редактирование конфига.
Вылезет такое меню и для начала переходим в general setup.
(управление стрелками вверх вниз, для перехода по меню enter, и стрелки влево вправо, чтобы внизу выбрать select(для подтвержения), exit (для выхода из меню и подменю),
help. save, load - пробел, чтобы поставить галочку)./
дальше ставим свою версию ядра и отмечаем галачку где показано.
По желанию ставим модули(нам это не нужно)
Переходим в networking support, затем в wireless и ставим галку там, где показанно для того чтобы включить возможность подключения устройств
Затем переходим на главную страницу и заходим в device drivers
Далее в network device support
Далее в wireless lan
и как раз тут мы выбираем те wifi адаптеры, которые хотим добавить(лично я буду добавлять эти)(некоторые надо помечать пробелом и переходить в них с помощью ентера)
далее выходим обратно в Network device support и заходим в USB network adapters
И помечаем
Далее переходим обратно в Device Drivers и ищем usb support(просто проверка)и переходим в него
помечаем
обратно в device drivers и переходим в hid support (подразумивается что вы выбрали исходники ядра уже с поддержкой hid)
Проверяем чтобы везде были пометки
Все, теперь сохраняем и выходим.
Пишем:
$ cp ./.config out #чтобы скопировать наш конфиг в папку
$ make clean && make mrproper #чтобы очистить и подготовить все
$ make -j4 #чтобы начать компиляцию в папку out(-j4 это значит использовать 4 ядра пк! ставте больше или меньше смотря сколько у вас ядер!)пойдет процесс сборки
Все необходимые файлы будут в папке arch/arm/boot/
Примечание:
Если у вас ошибки при компиляции, просто удалите папку out командой $ rm -R out, затем заного делаете все команды, надо будет писать make O=$TARGET *команда*
$ make O=$TARGET mrproper
$ make O=$TARGET -j4
Сборка ядра Linux для Android
Все мы привыкли, что мобильный телефон это только средство связи которое невозможно кастомизировать и представляется нам как законченный продукт в прошивку которого практически невозможно внести более менее серьезные изменения. Замена иконок и прочей визуальной составляющей не в счет. Такие времена потихоньку уходят в прошлое за счет появления более "умных" мобильных телефонов и все более заметном тренде по замене больших, неповоротливых десктопов на ноутбуки, планшеты и мобильные телефоны. Нельзя не упомянуть и Google с их открытой операционной системой Android, ведь во многом благодаря этой компании и открытому коду ее ОС под лицензией GPL, каждый имея немного знаний может добавить/убрать ненужный функционал из ядра или прошивки.
Чтож, от теории и вступления пора перейти к практике и попробовать собрать ядро для своего Android смартфона. Для старта нам потребуется телефон с root доступом, процесс получения которого у каждой модели разный, но это выходит за рамки данной статьи. Пример для LG Optimus Black вы можете посмотреть тут.
Сразу отмечу еще одну немаловажную особенность этой статьи. Так как задача данной статьи дать _общие_ понятия о сборке ядра для Android устройств которых так нехватает на просторах интернета -- я не буду зацикливаться на каком то конкретном устройстве и не буду углубляться в тонкости сборки которые обычно специфичны для каждого устройства. Все статьи по теме которые я читал в интернете были очень "узкими" и после их прочтения четкая картинка о том как все это работает у меня не получалась.
Главным элементом для сборки будет наличие установленного GNU/Linux дистрибутива. Для сборки под Android я бы лично порекомендовал Ubuntu или Xubuntu, так как в процессе будет гораздо меньше вопросов, да и все пакеты легко ставятся из репозиториев, Вам остается только правильно ими воспользоваться. Следующим элементом будет получение исходных текстов ядра и/или прошивки с сайта производителя вашего устройства. Вендор обязан открыть исходники своей прошивки и ядра если он использует Android и нагуглить ссылку на загрузку обычно занимает не более пяти минут. Как только исходники ядра получены следует распаковать их в произвольную директорию домашнего каталога вашего пользователя допустим
/home/vasya/android
Само собой, что директорию android нужно предварительно создать. На самом деле никогда не стоит пренебрегать файлом README, который лежит в архиве предоставленном производителем девайса, там может оказаться множество полезных вещей.
Следующим шагом будет выбор окружения для сборки или другими словами выбор тулчейна (toolchain). В состав тулчейна входит все что необходимо для кросскомпиляции под архитектуру ARM, компилятор, линковщик и т.д. Такое окружение предоставляет проект Linaro и NDK от Google. Понимание чем именно собирать придет позже вместе с осознанием того какие ништяки предоставляет тот или иной тулчейн. Для начала я все же рекомендовал бы использовать тулчейн который идет в составе NDK, так как если что то не работает, или что то не получилось, то локализовать эту ошибку будет гораздо проще. Получить NDK также не составит труда и Google все расскажет гораздо лучше чем я.
Получив архив с NDK нужно также распаковать его в какую либо директорию, например
/home/vasya/toolchain
По желанию можно добавить директорию с бинарными файлами тулчейна в переменную $PATH. Здесь я написал по желанию, так как лучше задавать используемый кросскомпилятор совместно с make непосредственно перед началом сборки, потому как задание опций сборки таким способом имеет высший приоритет и не учитывает Makefile в котором также может быть определен несуществующий кросскомпилятор.Теперь когда у нас настроено окружение для сборки нужно настроить параметры сборки или другими словами найти конфиг с которым собрано ядро. Как вытащить конфиг из телефона я писал здесь Если конфиг вытащить не удалось то стоит открыть вышеупомянутый README в котором описаны способы получения дефолтного конфига для Вашего устройства. В моем случае все свелось к выполнению
make sniper_rev_a_emmc_defconfig ARCH=arm
находясь в директории с исходниками ядра. Это создает дефолтный конфиг с которым ядро соберется и скорее всего заработает. Всевозможные дефолтные конфиги вы всегда можете посмотреть в
arch/arm/configs
Какой именно конфиг использовать - нужно узнавать у производителя, если конечно такую информацию он предоставил, или опять же спрашивать у всезнающего Google.
Заключительным шагом по сборке ядра будет выполнение команды make и собственно сборка ядра
make ARCH=arm CROSS_COMPILE=/home/vasya/android/toolchains/ndk/bin/arm-linux-androideabi-
После успешной сборки ядра его образ Вы можете найти в
arch/arm/boot/zImage
P.S. ни одна статья не бывает идеальна и уж тем более не может описывать все возможные вариации, поэтому если Вы хотите что то добавить или исправить я всегда пойду навстречу в этом.
Компиляция ядра Linux для Android устройств с помощью NDK или Linaro
В этой статья я постарался написать универсальную инструкцию по сборке ядра для android устройств.ВНИМАНИЕ: Всё действия, описанные в данной статье, вы будете делать на свой страх и риск. Автор не несёт никакой ответственности за повреждение вашего устройства.
Рекомендую тщательно изучить специализированный материал по вашему аппарату.
Приведённые ниже команды нужно выполнять в терминале.
I. Подготовка
1.1. Для начала нужно установить 64-разрядный Linux дистрибутив Ubuntu (для компиляции ядра я использовал Ubuntu 13.04 x64). В принципе, если у вас нормальный ПК, то можно поставить на виртуальную машину. Как установить Ubuntu в VirtualBox по версии Google.
1.2. Также нужно иметь исходный код ядра вашего устройства (например, для Nook Color). Вот несколько ссылок, по которым вы можете получить исходники:
HTC1.3. Установить Android SDK Tools
LG
SAMSUNG
SONY
1.4. Скачать NDK Linux 32-bit (x86)
1.5. Скачать Linaro инструментарий
1.6. После установки нужно создать необходимые папки в домашней директории:
mkdir -p ~/Kernel ~/Kernel_output/modules ~/NDK ~/LINAROKernel - Корневая директория исходного кода ядра вашего устройства. Его можно получить через git clone (например, если располагается на github.com) или просто распаковав скачанный архив c исходниками.
ПРИМЕР: Получения нужных файлов с GitHub.com для планшета B&N Nook Color (encore):
git clone https://github.com/CyanogenMod/android_kernel_bn_encore.gitKernel_output - Здесь будет итоговый файл ядра после компиляции (uImage).
Kernel_output/modules - А здесь будут располагаться модули ядра (*.ko) после компиляции.
NDK - Корневая директория NDK. Сюда распаковываем скаченный ранее NDK Linux 32-bit (x86).
LINARO - Корневая директория Linaro. Сюда распаковываем скаченный ранее Linaro инструментарий.
II. Компиляция ядра с помощью NDK или Linaro
2.1. Переходим в корневую папку ядра
cd Kernel2.2. Делаем экспорт системных переменных (работают только на сессию с текущим терминалом)
2.2.1. Во первых, объявим переменную, которая указывает на целевую архитектуру компиляции (ARM)
export ARCH=arm2.2.2. Во вторых, также объявим переменную, которая указывает на сами исполняемые файлы инструментария для NDK (пункт 2.2.2.1) или для Linaro (пункт 2.2.2.2).
Для заметки: Можно использовать только одну переменную CROSS_COMPILE, если вы введёте все ниже следующие команды, то последняя окажется действующей. Можно проверить командой export без параметров и посмотреть ваши переменные.
2.2.2.1. Для NDK (GCC 4.4.3, GCC 4.6.x или GCC 4.7.x соответственно)
export CROSS_COMPILE=~/NDK/toolchains/arm-linux-androideabi-4.4.3/prebuilt/linux-x86/bin/arm-linux-androideabi-или
export CROSS_COMPILE=~/NDK/toolchains/arm-linux-androideabi-4.6/prebuilt/linux-x86/bin/arm-linux-androideabi-или
export CROSS_COMPILE=~/NDK/toolchains/arm-linux-androideabi-4.7/prebuilt/linux-x86/bin/arm-linux-androideabi-2.2.2.2. Для Linaro
export CROSS_COMPILE=~/LINARO/bin/arm-linux-androideabi-2.3. Чистим директорию ядра от прошлых операций и приводим в порядок
make clean && make mrproperНа некоторых 64 разрядных дистрибутивах Ubuntu необходимо установить 32 битные библиотеки, чтобы избежать ошибку "... : Command not found"
sudo apt-get install ia32-libs2.4. Получаем файл конфигурации
2.4.1. Он обычно находится в ~/Kernel/arch/arm/configs, где нужный файл будет примерно таким: *_defconfig или *.defconfig (где * - (кодовое) название вашего устройства)
2.4.1.1. Для того, чтобы получить файл конфигурации, который использовался при компиляции ядра вашего устройства, можно:
Способ 1. На самом девайсе в Terminal Emulator набрать
cp /proc/config.gz /sdcardНа microSD карте появиться архив config.gz, распаковываем его в корневую директорию исходников ядра (~/Kernel) и переименовываем файл из config в .config
Способ 2. Через ADB
adb pull /proc/config.gz .Если вы получили файл конфигураций с устройства, то переходите к пункту 2.5
gunzip config.gz
mv config .config
2.4.2. Введите следующую команду
make *_defconfig2.5. Если нужно, производим модификации файла конфигурации
make menuconfigНа некоторых дистрибутивах Ubuntu (например, 12.04) чтобы использовать "make menuconfig" необходимо установить ncurses
sudo apt-get install libncurses5 libncurses5-devЕсли требуется подгружать в ядро собственные модули, то необходимо выбрать соответсвующий пункт в меню:
[*] Enable loadable module supportПосле внесённых изменений необходимо сохранить файл конфигурации.
2.6. Компилируем ядро
make -j4 uImageили
make -j4 zImageили
make -j4 ImageВыполняем подходящую команду компиляции. В случаем компиляции uImage или zImage не cжатый образ ядра Image компилируется автоматически.
Цифра после -j означает количество ядер центрального процессора ПК (у меня 4).
uImage, zImage или просто Image - образ скомпилированного ядра.
Если в процессе компиляции uImage у вас выходит ошибка "mkimage" command not found - U-Boot images will not be built, то установите недостающий пакет:
sudo apt-get install uboot-mkimageи начните с пункта 2.3
2.7. Если необходимы модули ядра, то компилируем и их
make modules2.8) Копируем скомпилированное ядро в директорию ~/Kernel_output
cp arch/arm/boot/uImage ../Kernel_output/uImageили
cp arch/arm/boot/zImage ../Kernel_output/zImageили
cp arch/arm/boot/Image ../Kernel_output/ImageВыполняем команду соответствующую нужному скомпилированному ядру.
2.9. Если компилировали и модули, то копируем их в директорию ~/Kernel_output/modules
find . -name "*.ko" -exec cp {} ../Kernel_output/modules \;III. Установка ядра (и модулей к нему) на устройство
Для устройств с boot.img - нужно сначала собрать соответствующий вашему устройству образ boot.img, а только потом уже проводить нижеследующие операции.
Несколько ссылок для размышлений:
Инструкции по распаковке, редактированию и запаковке boot.img
Очень удобные скрипты для редактирования boot.img
Способов установки ядра (и модулей к нему) на устройство несколько, рассмотрим основные:
3.1. Простая замена файлов *.zip архив обновления ядра или прошивки для ClockworkMod Recovery (CWM)
Нужно заполучить *.zip архива обновления ядра или прошивки для CWM под ваше устройство и произвести замену файлов на новые. В корне архива может находится kernel или uImage или zImage или boot.img - нужно его удалить и взамен поместить ваши файлы с названием удалённого файла (если был kernel, то конечный файл тоже должен быть kernel). А модули поместить в директорию system\lib\modules\. Произвести инсталляцию через CWM.
3.2. Поместить скомпилированные файлы на девайс с помощью ADB и Fastboot. Более подробно можно почитать здесь.
IV. Заключение
Если вы снова захотите скомпилировать ядро, то повторите все шаги начиная с пункта 2.1
Компиляция ядра Linux
Собирая ядро операционной системы Linux под конкретную аппаратную архитектуру, мы выигрываем в производительности, что особенно заметно на нетбуках, к тому-же тем самым уменьшаем размер ядра, что так-же необходимо для повышения стабильности и производительности. Компиляция иногда бывает необходима, чтобы включить в ядро дополнительные опции (патчи) которых нет в дефолтной конфигурации. Пересборка ядра важна ещё и из соображений безопасности. Дело в том, что в эксплойтах (программы использующие дыры в системе для несанкционированного доступа) жёстко прописаны адреса кода и переменных, а когда мы пересобираем ядро, мы меняем его размер и соответственно меняется адресная структура. После компиляции с большой долей вероятности на нашей системе эксплоит просто не будет работать.Финальная цель в сборке ядра - монолитное ядро.
Скачайте полный архив исходного кода ядра Linux нужной вам версии с официального сайта https://www.kernel.org/ нажав справа на ссылку [Full Source] и переместите скачанный архив исходного кода ядра в вашу домашнюю папку.
Так-как все дальнейшие действия будут проходить в домашней папке, для удобства получения информации о названиях её содержимого (архивов, папок, пакетов и т.д которые вам будут часто требоваться) вводите команду в терминале:
ls -l
*( терминал можно открыть с помощью комбинации клавиш Ctrl+Alt+T )
Распакуйте в вашу домашнюю папку полученный архив (в дальнейшем вместо x.y указывайте версию полученного архива, либо deb пакета, либо ядра смотря, что требуется) командой:
cd ~/
tar -xjf linux-2.6.x.y.tar.bz2
Установите необходимые пакеты для сборки ядра Linux:
sudo apt-get install build-essential kernel-package libncurses-dev
Установите пакеты необходимы для запуска GUI конфигуратора ядра xconfig:
sudo apt-get install qt3-dev-tools libqt3-mt-dev
Конфигурирование ядра Linux перед сборкой.
Переходим в домашнюю папку с распакованными сорцами ядра:
cd ~/linux-2.6.x.y
Получаем файл текущей (рабочей) конфигурации ядра, в директории с сорцами появится файл .config, мы будем на нём основываться:
sudo make oldconfig
Запускаем GUI (графический) конфигуратор ядра xconfig:
sudo make xconfig
Конфигурируем ядро согласно аппаратной архитектуре компьютера.
В конфигураторе в общих чертах (на английском) даётся описание к редактируемым параметрам.
С помощью комбинации клавиш Ctrl+F найдите и отключите лишнее, типа разновидности драйверов для ноутбуков, видео карт, типы процессоров и прочего, что не связанно с названиями архитектуры компьютера для которого вы оптимизируете ядро.
Например:
Ноутбуки: MSI, Apple, Samsung, Sony, Toshiba, BenQ, Panasonic, Asus, Dell, Compaq, Toshiba, Acer, Fujitsu, Siemens
Процессоры: AMD, CELERON, INTEL, Intel Core 2
Видео карты: NVIDIA, GeForce, Zotac, Radeon
Заранее выясните следующие интересующие вас параметры (этот список не полный):
процессор(ы)
оперативная память
чипсет материнской платы
видеокарта
сетевая карта(ы)
звуковая карта и прочее мультимедийное оборудование
жесткие диски и CD/DVD приводы
устройства ввода/вывода (клавиатура, мышь, планшеты и т.д.)
файловые системы
параметры сети (протоколы разных уровней)
системы и алгоритмы шифрования
usb-устройства и т.д.
Узнать некоторую информацию об аппаратной архитектуре можно с помощью графических утилит и команд в терминале:
Команды для получения системной информации:
arch : архитектура компьютера
uname -m : архитектура компьютера (2)
dmidecode -q : аппаратные системные компоненты - (SMBIOS / DMI)
hdparm -i /dev/hda : характеристики жесткого диска
cat /proc/cpuinfo : информация о процессоре
cat /proc/net/dev : показать сетевые интерфейсы и статистику по ним
lspci -tv : показать в виде дерева PCI устройства
lsusb -tv : показать в виде дерева USB устройства
lspci - выводит список PCI устройств: чипсет, контроллеры видео, сетевые конроллеры и т.д.
lsusb - список USB устройств: клавиатуры, мышки, вэб-камеры и т.д.
Обе эти команды можно использовать с ключом -v для получения более подробной информации об устройствах.
dmesg - получение сведений об устройстве или группе устройств, например подробные сведения о процессоре можно получить так:
dmesg | grep CPU
Отключая параметры вы должны быть точно уверенны в том, что делаете если в чём-то сомневаетесь оставьте, как есть в противном случае операционная система будет не рабочей либо частично, либо полностью.
После оптимизации и сохранения конфигурационного файла ядра Linux, преступаем к компиляции ядра, (сборка ядра может занять от 20 минут до нескольких часов в зависимости от конфигурации ядра и технических характеристик компьютера, custom это особое название для вашего будущего ядра, его вы можете заменить своим) выполним команду:
fakeroot make-kpkg --append-to-version=-custom kernel_image kernel_headers
После успешной компиляции ядра Linux, в вашей домашней папке появятся два deb-пакета. Устанавливаем их командой:
cd ~/
sudo dpkg -i linux-headers-2.6.x.y-custom_2.6.x.y-custom-10.00.Custom_arc.deb
sudo dpkg -i linux-image-2.6.x.y-custom_2.6.x.y-custom-10.00.Custom_arc.deb
Для корректной работы, Ubuntu требует наличие образа начального RAM-диска. Чтобы его создать, выполните команду (где 2.6.x.y это версия собранного ядра):
sudo update-initramfs -c -k 2.6.x.y-custom
Проинформируем загрузчик Grub о собранной версии вашего ядра Linux для того, чтобы ваше ядро было выбрано при загрузке:
sudo update-grub
Все этапы компиляции ядра Linux завершены, перезагрузите компьютер.
Чтобы посмотреть с каким ядром запустилась операционная система, выполните команду:
uname -r
Если смена на новое ядро не произошла автоматически, а ОС загрузилась с прежним ядром (такое может быть), то измените порядок загрузки ядра сами используя к примеру графическую утилиту StartUp Manager
для установки утилиты воспользуйтесь командой:
sudo apt-get install startupmanager
После проделанной сборки ядра Linux, можно удалить из домашней папки оставшиеся deb пакеты, скачанный архив и разархивированный каталог. Так-же если вы не планируете повторную компиляцию ядра, удалите ранее установленные пакеты для компиляции и конфигурации.
Для удаления всех пакетов вводим:
sudo apt-get autoremove build-essential kernel-package libncurses-dev qt3-dev-tools libqt3-mt-dev
Как использовать ядро Linux 5 в Ubuntu 18.04 LTS
Ubuntu 18.04 LTS — это текущая стабильная версия операционной системы Canonical Linux. Благодаря усилиям по поддержке он включает в себя множество современного программного обеспечения. Несмотря на это, пользователи, как правило, застревают на устаревшей версии ядра Linux.
Не так уж и плохо быть на Ubuntu LTS и застрять на старом ядре Linux, поскольку разработчики делают все возможное, чтобы выпускать исправления и улучшать порты.Тем не менее, если вы используете 18.04 из соображений стабильности, но предпочитаете использовать самое последнее и лучшее ядро Linux (например, ядро 5), вы будете немного раздражены. К счастью, благодаря сообществу Linux становится все проще и проще использовать Linux Kernel 5 на Ubuntu 18.04 LTS
.Метод 1 - от UKUU
Средство обновления ядра Ubuntu — это самый простой способ получить Linux с помощью ядра Linux 5 в Ubuntu 18.04 LTS. Чтобы получить доступ к приложению, вам нужно перейти к нашему руководству по установке приложения UKUU.
Когда приложение UKUU запущено в Ubuntu, запустите его, просмотрев его в меню приложения. Затем используйте приложение UKUU, чтобы найти версию 5 ядра Linux (желательно последнюю доступную версию).
Выберите ядро v5, которое вы хотите установить в Ubuntu 18.04 LTS, с помощью мыши. Затем начните установку нового ядра, нажав кнопку «Установить», чтобы загрузить его в свою систему.
Разрешить приложению UKUU полностью загрузить и установить ядро Linux версии 5 на ваш ПК с Ubuntu Linux.После завершения процесса установки закройте приложение UKUU и перезапустите Ubuntu 18.04 LTS. Когда он загрузится, вы должны использовать версию 5 ядра Linux.
Хотите убедиться, что вы используете самую последнюю версию ядра и что UKUU работает должным образом? Запустите окно терминала, нажав Ctrl + Alt + T или Ctrl + Shift + T и введите:
имя-r
Метод 2 - из источника
Инструмент обновления ядра Ubuntu — хороший инструмент, но, учитывая, что он обычно работает с версиями ядра Linux, разработанными Canonical, все может стать немного нестабильным.Для более стабильного решения вы можете собрать Linux самостоятельно.
Чтобы начать процесс компиляции, необходимо создать новый файл конфигурации. Самый быстрый и простой способ сделать это — получить существующий файл конфигурации, который мы настроили.
Примечание. Вы не хотите использовать наш готовый файл конфигурации? Скопируйте существующий файл из /boot и сохраните его как «.config».
wget https://pastebin.com/raw/Pwz0Uyqn-O.конфиг
После загрузки файла конфигурации пришло время загрузить последнюю версию ядра Linux. На момент написания статьи версия 5.0.8.
Примечание. Версии ядра регулярно публикуются на Kernel.org. Если вы хотите в будущем обновиться до версии 5.0.8, перейдите туда, загрузите новый источник и следуйте инструкциям в этом руководстве.
wget https://cdn.kernel.org/pub/linux/kernel/v5.x/linux-5.0.8.tar.xz
Распакуйте архив ядра 5.0.8 с помощью команды Tar.
tar xvf linux-5.0.8.tar.xz
Переместите новый файл конфигурации в папку кода Linux с помощью команды mv.
МВ .config ~/linux-5.0.8/
Установите зависимости сборки ядра в Ubuntu, чтобы вы могли их скомпилировать и собрать.
sudo apt install build-essential libncurses5-dev gcc libssl-dev bc flex bison
Запустите инструмент меню графического интерфейса ядра с помощью make menuconfig
cd~/linux-5.0,8/
сделать менюконфиг
В меню приложения оставьте настройки по умолчанию и с помощью клавиш со стрелками выберите «Сохранить». Не забудьте сохранить файл в «.config».
Закройте инструмент меню, выделив «Выход».
После выхода из редактора меню GUI пришло время использовать команду lscpu, чтобы узнать, сколько ядер у вашего компьютера, чтобы определить, сколько процессоров вы можете использовать для компиляции вашего ядра.
Чтобы узнать, сколько ядер вы запустили:
ЛСКПУ | grep -E '^ ЦП (' Запомните этот номер.Затем используйте make с deb-pkg, чтобы начать компиляцию для Ubuntu. Обязательно измените «CORE-NUMBER» на число, которое появляется при запуске команды lscpu.
make -jCORE-NUMBER deb-pkg
В зависимости от количества имеющихся у вас процессорных ядер эта компиляция займет много времени. Для достижения наилучших результатов постарайтесь собрать как минимум двухъядерный процессор (2). Когда сборка будет завершена, компилятор отобразит четыре готовых к использованию пакета DEB для нового ядра, которые вы можете установить.
Чтобы установить только что скомпилированное ядро Linux версии 5.0.8, выполните команду dpkg.
sudo dpkg -i linux-*.deb
Предполагая, что dpkg успешно установлен, перезагрузите компьютер Linux. Когда он вернется в сеть, вы должны использовать Ubuntu 18.04 LTS на ядре Linux версии 5.
Чтобы убедиться, что вы действительно используете ядро 5 в Ubuntu 18.04 LTS, используйте команду uname.
имя-r.
Сборка ядра Linux для конкретной машины с помощью Debian
На каждой машине с дистрибутивом Linux есть встроенное ядро. оперативный, который управляет практически всеми аспектами работы такого компьютера. В раздаче Debian, ядро поставляется в пакетах с именами, начинающимися с linux-image-*. Эти пакеты созданы нужными людьми из команды Debian и доступны для простого использования. установка конечным пользователем.Тем не менее такое ядро должно работать на том, как самое большое количество компьютеров и, таким образом, имеет множество модулей, которых у нас никогда не было на нашей машине не будет использоваться. Этот факт не оказывает существенного влияния на работу машины, но когда позже вам нужно настроить ядро немного по-другому, например, включив один или два варианта или применение исправления, которое не было применено разработчиками Debian, затем вам придется перекомпилировать такое ядро самостоятельно, а это займет много времени.Вместо из этого можно попробовать подготовить ядро под конкретное железо, исключив всю массу лишние вещи и ограничение времени сборки всего ядра оперативный. Есть ли какой-нибудь простой способ собрать такое ядро самостоятельно с его помощью? минимальное знание параметров ядра, которое может доставить нам головную боль? Оказывается, что да, и в этой статье мы пройдем весь процесс.
Исходники ядра и зависимости
Прежде всего, чтобы иметь возможность играть с компиляцией ядра, мы должны получить исходные коды ядра, а те, в свою очередь, мы можем либо получить его из дистрибутива Debian, либо напрямую из ядра.орг. Без какие источники мы выбираем - они почти идентичны, если предположить, что цифры они согласны. Почти, и это потому, что ядро Debian поставляется с рядом исправлений безопасности, которые они будут применяться по умолчанию. Если мы хотим голое ядро, мы должны загрузить его с официального сайта. ядро. Если мы выберем исходный код ядра Debian, мы выполним следующую команду в терминале:
# aptitude install linux-source После скачивания пакета исходники будут установлены в директорию /usr/src/linux-*/, где * номер ядра.
Также необходимо установить ряд зависимостей, необходимых в процессе сборки исходников ядра:
# установка aptitude \ необходимая сборка \ до н.э \ кмод \ cpio \ гибкий \ libncurses5-dev \ libssl-dev \ libelf-dev \ qt5-по умолчанию \ Начальная конфигурация системы и переменные среды
Оказывается, при сборке пакета ядра Debian подход немного отличается для экспорта переменных окружения, мин. при установке флагов для компилятора и компоновщика.
Как правило, люди также пытаются экспортировать переменную $ ARCH в конфигурацию оболочки, чтобы процесс сборник, он мог подобрать его. Переменная $ ARCH указывает архитектуру нашей системы и будет он виден в процессе компиляции, но мы не должны экспортировать его таким образом. Дело в том, что некоторые инструменты Debian могут быть перепутаны, если оставить эту переменную в конфигурации набор ракушек. Ниже приведен пример обновления системы, в частности одного из пакетов DKMS:
#cat/var/lib/dkms/xtables-addons/3.2 /сборка/make.log DKMS make.log для xtables-addons-3.2 для ядра 4.19.13-amd64-morphic (x86_64) Чт, 3 января, 10:57:49 CET 2019 make: Вход в каталог '/usr/src/linux-headers-4.19.13-amd64-morphic' Makefile: 618: arch // Makefile: Нет такого файла или каталога make: *** Нет правила для создания целевого 'arch// Makefile'. Останавливаться. make: Выход из каталога '/usr/src/linux-headers-4.19.13-amd64-morphic' И как видно из ошибки выше, компиляция этого модуля не удалась, т.к. arch // Makefile не найден.Чтобы исправить эту ошибку, нужно удалить переменную $$ARCH из среду на отключить или просто не экспортировать его.
Вместо экспорта $ ARCH глобально, лучше поставить в команде из сделать , например:
make ARCH = "x86_64" -j2 bindeb-pkg Что касается флагов компилятора и компоновщика, то эта тема немного скомпилирована.
Скрипты /package/mkdebian script и debian/rules
Прежде всего, при создании цели bindeb-pkg очень простой конфигурация инструментов Debian в подкаталоге debian / .Моменты после вызова команды make bindeb-pkg скрипт scripts/package/mkdebian вызывается, что бы его дополнить серия файлов на основе некоторых переменных (по крайней мере с установленной ранее переменной $ARCH ). Эти файлы перезаписываются каждый раз при вызове make bindeb-pkg и вообще в эти файлы мы не должны редактировать вручную. Сценарий также в основном не о чем двигаться.
$ CFLAGS, $ CPPFLAGS, $ CXXFLAGS и $ LDFLAGS
Технически процесс сборки пакета ядра почти такой же, как и в при сборке любого другого пакета.deb для дистрибутива Debian. Единственная разница в том, что ядро не является стандартным двоичным файлом ELF.
При сборке обычных пакетов различных приложений в файле debian/rules задается несколько настроек переменные, в т.ч. переменная $DEB_BUILD_MAINT_OPTIONS , которая предварительно настраивает переменные для компилятор и компоновщик. В принципе, все стандартные флаги компиляции могут быть настраивается этой переменной $DEB_BUILD_MAINT_OPTIONS , например:
экспорт DEB_BUILD_MAINT_OPTIONS = укрепление = + все DPKG_EXPORT_BUILDFLAGS = 1 включить /usr/share/dpkg/buildflags.тк По крайней мере, так обстоит дело с обычными приложениями. Что касается самого процесса компиляции ядро, то установка переменной $DEB_BUILD_MAINT_OPTIONS ничего нам не даст. Так же, как руководство установка переменных $CFLAGS , $CPPFLAGS , $CXXFLAGS и $LDFLAGS в конфигурации оболочки, потому что они вообще не будут учитываться.
Если кто-то захочет установить эти переменные, то мне придется это сделать через файл debian/rules , т.е.по скрипту scripts/package/mkdebian добавление прямо по адресу:
... кошка << EOF> debian / правила #!$(команда -v$СДЕЛАТЬ)-f ... следующие строки кода:
CFLAGS+=-march=native -O2 -pipe -Wall -fstack-clash-protection -fpic CXXFLAGS+=-march=native -O2 -pipe -Wall -fstack-clash-protection -fpic CPPFLAGS+=-march=native-O2-pipe-Wall-fstack-clash-protection-fpic LDFLAGS + = -Wl, -O2 -Wl, - по необходимости -Wl, -z, defs -Wl, -shared Какие флаги будут установлены на самом деле можно посмотреть добавив debian/rules в файл (благодаря скрипту) следующей команды в целевой сборке :
... строить: dpkg-buildflags --статус ... Утилита dpkg-buildflags может устанавливать следующие флаги:
-
$ CFLAGSзадает флаги для компилятора C. Флаги по умолчанию включают-gи-O2, если только что вDEB_BUILD_MAINT_OPTIONSопределеноnoopt, а затем используется-O0. -
$ CXXFLAGSуказывает флаги для компилятора C++. То же, что и $CFLAGS. 90 135 -
$ FCFLAGSопределяет флаги компилятора Fortran 9x. То же, что $CFLAGS -
$ FFLAGSопределяет флаги компилятора Fortran 77. Подмножество$ CFLAGS. -
$ GCJFLAGSопределяет флаги компилятора GNU Java (gcj). Подмножество $$CFLAGS. -
$ LDFLAGSопределяет флаги компоновщика.По умолчанию пусто. -
$ OBJCFLAGSуказывает флаги объектно-ориентированного компилятора C. То же, что $$ CFLAGS. -
$ OBJCXXFLAGSуказывает флаги объектного компилятора C++. То же, что и$ CXXFLAGS.
$ CPPFLAGS задает флаги препроцессора C (процессор C P re P ). По умолчанию пусто. Если мы начнем процесс сборки сейчас, dpkg-buildflags --status даст нам что-то вроде следующий код:
... dpkg-buildflags --статус dpkg-buildflags: статус: переменная среды DEB_BUILD_OPTIONS = parallel = 2 dpkg-buildflags: статус: переменная среды DEB_HOST_ARCH = amd64 dpkg-buildflags: статус: производитель Debian dpkg-buildflags: статус: будущие функции: lfs = нет dpkg-buildflags: status: функции усиления: bindnow = no format = yes fortify = yes pie = yes relro = yes stackprotector = yes stackprotectorstrong = yes dpkg-buildflags: статус: функции qa: ошибка = нет canary = нет dpkg-buildflags: статус: воспроизводимые функции: fixdebugpath = yes fixfilepath = no timeless = yes dpkg-buildflags: статус: функции очистки: адрес = нет утечки = нет потока = нет не определено = нет dpkg-buildflags: статус: CFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19 =. -fstack-protector-strong -Wformat -Werror = безопасность формата dpkg-buildflags: статус: CPPFLAGS [поставщик]: -Wdate-time -D_FORTIFY_SOURCE = 2 dpkg-buildflags: статус: CXXFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19=. -fstack-protector-strong -Wformat -Werror = безопасность формата dpkg-buildflags: статус: FCFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19=. -fstack-протектор-сильный dpkg-buildflags: статус: FFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19 =. -fstack-протектор-сильный dpkg-buildflags: статус: GCJFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19=. -fstack-протектор-сильный dpkg-buildflags: статус: LDFLAGS [поставщик]: -Wl, -z, relro dpkg-buildflags: статус: OBJCFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19=. -fstack-protector-strong -Wformat -Werror = безопасность формата dpkg-buildflags: статус: OBJCXXFLAGS [поставщик]: -g -O2 -fdebug-prefix-map=/usr/src/linux-source-4.19=. -fstack-protector-strong -Wformat -Werror = безопасность формата ... Конфигурацией функциональных областей вы можете влиять на то, какие флаги будут установлены. Подробно описано, какие флаги определяют эти области функций. в руководстве dpkg-buildflags.
Флаги компилятора
Ниже приведен краткий обзор флагов компилятора, используемых при построении кода. источник:
- Флаг
-march=указывает, для какого процессора строится код. В случае, если мы скомпилируем ядро (или вообще любой код) только для нашей машины, нам не нужно заморачиваться head со свойствами своего процессора.В этом случае вы можете указатьроднойи компилятор здесь он выберет этот процессор и сам выберет соответствующие флаги. - флаг
-Oотвечает за степень оптимизации кода. Есть несколько степеней:0,1,2,3,с,гибыстро. Каждый уровень имеет разные флаги, но рекомендуемый уровень2. - флаг
-pipeне транслирует в сгенерированный код как таковой, но может заставить процесс более быстрая компиляция за счет использования каналов вместо физических временных файлов.Такое решение, однако, связано с большим аппетитом процесса компиляции к оперативной памяти и Этот флаг не следует использовать, когда нашему компьютеру не хватает памяти, чтобы справиться с обрабатывать процесс компиляции, потому что компилятор может быть убит системой. - Флаг
-gсоздает информацию, используемую для отладки в собственной операционной системе. формат (stabs, COFF, XCOFF или DWARF). - флаг
-Wallделает все предупреждения видимыми в процессе компиляции. - флаги
-Werror=*отвечают за возведение определенных групп предупреждений в ранг ошибки, что эффективно завершает процесс компиляции при появлении такого предупреждения. - флаг
-Форматпроверяет, указаны ли вызовыprintfиscanfи т. д. в соответствующем формате. - флаг
-fstack-protector-strongпредназначен для защиты стека от преднамеренного повреждения (разгром стека/переполнение буфера стека). - флаг
-fstack-clash-protectionпредназначен для защиты стека от атак с конфликтом стека. - флаг
-D_FORTIFY_SOURCE=2отвечает за замену небезопасных вызовов функций на неограниченный размер буфера с теми, которые имеют такой предел. - флаги
-pieи-fPIEделают исполняемые файлы независимыми от позиции (Position Independent Исполняемый файл) может использовать ALSR (рандомизация адресного пространства). - флаг
-fpicгенерирует независимый от местоположения код (позиционно-независимый код, PIC) для разделяемых библиотек.
Флаги компоновщика
Что касается флагов компоновщика, то они передаются не напрямую компоновщику ( ld ), а компилятор ( gcc ). Поэтому перед каждым флагом компоновщика должен стоять флаг -Wl :
- флаг
-Oотвечает за степень оптимизации кода. - Флаг
--as-neededуказывает компоновщику связывать только те библиотеки, которые содержат символы, используемые этим конкретным двоичным файлом.Больше информации здесь. - флаг
-z, relroпроверяет при загрузке программы Разделы памяти ELF, которые должны быть записаны компоновщиком, будут изменены только для чтения прежде чем передать управление этой программе. Это защищает от некоторых атак GOT (Global Таблица смещения). - флаг
-z, теперьделает все динамические символы присутствующими при загрузке программы решено, что позволяет пометить GOT как доступную только для чтения. Однако он может носить с собой некоторые проблемы с производительностью при загрузке больших приложений.
Подробнее о флагах можно прочитать здесь и здесь.
Ядро закалки
На самом деле нам не нужно самостоятельно устанавливать какие-либо из описанных выше флагов. Все что должен быть установлен, он будет установлен автоматически, и никаких дополнительных действий предприниматься не будет. мы должны провести. Тем не менее, в Интернете можно встретить различные формы закалки. ядро, установив флаги. Однако оказывается, что манипулирование флагами не влияет ни на один из них. путь для того, что будет собрано из исходников ядра, по крайней мере, при вызове сделать bindeb-pkg .Как правило, любое изменение флагов должно перестраивать часть или весь код. с самого начала при использовании ccache но это не так. После смены флагов Cache HIT растет, а не должно. Поэтому все самое интересное с усилением ядра флагами возможно пожертвовать.
Когда дело доходит до настоящего усиления защиты ядра, вы должны подходить к этой задаче со стороны страницы. конфигурации, а именно установить соответствующие опции в самом ядре.
Здесь стоит добавить, что hardening-check на распакованном бинарнике ядра вернет неверный результат независимо от того, с какими флагами мы будем компилировать исходный код ядра.Это потому что такие приложения, как hardening-check , предназначены для работы с обычными двоичными файлами ELF, а двоичные файлы ядро не считается таковым, и трудно ожидать, что эти инструменты вернут действительный результат.
Плагины GCC
Если мы поиграем с усилением ядра, настроив его правильно, это может пригодиться. также включите опции из плагинов GCC . Однако по умолчанию они неактивны или отключены и не будут работать. для их переключения без предварительной установки в систему gcc-8-plugin-dev :
# aptitude установить gcc-8-plugin-dev Теперь эти параметры должны быть активны.
Проблемы с xconfig
В принципе, ядро может настроить с помощью инструмента с графическим интерфейсом, введя команду make xconfig в терминале. это инструмент использует интерфейс QT, и нам понадобится qt5ct для его настройки. Поэтому мы должны установите следующий пакет:
# установка установки qt5ct В случае проблем со стрельбой qt5ct вам нужно будет экспортировать переменную $ QT_QPA_PLATFORMTHEME :
# экспорт QT_QPA_PLATFORMTHEME = "qt5c" кэш-память
Для дополнительного ускорения процесса перекомпиляции кода мы можем установить в систему ccache :
# aptitude установить ccache Также нужно сделать несколько ссылок, чтобы ccache использовался при компиляции:
#ln -s /usr/bin/ccache/usr/local/bin/gcc # ln -s /usr/bin/ccache/usr/local/bin/g++ # ln -s /usr/bin/ccache/usr/local/bin/cc # ln -s /usr/bin/ccache/usr/local/bin/c++ Нам также нужно экспортировать некоторые переменные:
# экспорт USE_CCACHE = "1" # экспорт CCACHE_DIR="/media/kernel/ccache" Размер кэша регулируется следующим образом:
# ccache -M 10G Установите предельный размер кэша 10.0 ГБ # ccache -s каталог кеша /media/kernel/ccache/ основная конфигурация /media/kernel/ccache/ccache.conf ... максимальный размер кэша 10,0 ГБ Версия gcc/g++/cpp
Debian имеет несколько версий компилятора gcc/g++ и препроцессора C. В настоящее время используется по умолчанию это версия 10. Однако вы также можете установить в своей системе версию 11, а не не должно быть проблемой. Однако проблема может заключаться в выборе версии этих инструментов. мы хотим использовать его при сборке ядра или других проектов.В таких ситуациях с помощью здесь идет система альтернатив, с помощью которой мы должны определить предпочтительную версию gcc/g++/cpp и ссылки на соответствующие бинарники будут созданы для нас автоматически. Несущий уже установили соответствующие пакеты, запустите терминал и введите в нем следующие команды.
Удаление старых альтернатив gcc/g++/cpp:
# update-alternatives --remove-all cc # update-alternatives --remove-all c++ # update-alternatives --remove-all gcc # update-alternatives --remove-all g++ # update-alternatives --remove-all cpp-bin Сейчас мы добавляем новые альтернативы:
#обновление-альтернативы --install /usr/bin/gcc gcc/usr/bin/gcc-10 50\ --slave /usr/bin/g++g++/usr/bin/g++-10 # update-alternatives --install /usr/bin/cpp cpp-bin/usr/bin/cpp-10 # update-alternatives --install /usr/bin/gcc gcc/usr/bin/gcc-11 100\ --slave /usr/bin/g++g++/usr/bin/g++-11 # update-alternatives --install /usr/bin/cpp cpp-bin/usr/bin/cpp-10 50 # update-alternatives --install /usr/bin/cpp cpp-bin/usr/bin/cpp-11 100 Здесь стоит упомянуть, что альтернативы g++ были добавлены с переключателем - раб .Таким образом, мы делаем альтернативы g++ зависимыми от gcc . Таким образом, вам просто нужно настроить Альтернатива gcc и альтернатива g++ будут скорректированы автоматически.
Так же устанавливаем ссылки cc/c++, чтобы они указывали на gcc/g++:
# update-alternatives --install /usr/bin/cc cc /usr/bin/gcc 30\ --slave /usr/bin/c++ c++/usr/bin/g++ И напоследок настраиваем предпочитаемую нами версию gcc/g++/cpp:
# альтернативы обновления --config gcc # варианты обновления --config cpp-bin Получить информацию об оборудовании
Что необходимо для сборки ядра, которое сможет полностью поддерживать наше оборудование? информация о модулях, которые необходимы каждому компоненту.Каждая часть оборудования работает в на основе некоторого модуля. Список загруженных в данный момент модулей в системе можно определить, выполнив команда lsmod . Однако здесь следует помнить, что это список модулей для устройств, которые в настоящее время они работают в системе, возможно, и те, которые были отключены от нее, но система не перезагружалась и модули не выгружались вручную. Поэтому было бы полезно на этом этапе подключите все устройства, которые мы собираемся использовать в будущем, например.Флешки, LTE-модемы, WiFi-карты, bluetooth-адаптеры, мышки, USB-клавиатуры и т. д. Сама система выберет подходящие модули и загрузит их для нас. Список этих модулей будет предоставлен во время начальная конфигурация ядра.
сделать localyesconfig
После загрузки всех необходимых модулей перейдите в исходный каталог и отпустите следующую команду:
# сделать localyesconfig Файл должен быть сгенерирован в рабочем каталоге.config , содержащий конфигурацию ядра. Возможно, нас попросят ответить на ряд вопросов о новых опциях, то есть те, которых не было в предыдущей конфигурации:
Вы можете легко ответить на все вопросы отрицательно, нажав N , если нет чего-то нам это нужно.
сделать xconfig
Имея конфигурацию в файле .config , мы можем ввести в терминал следующую команду:
# сделать xconfig Мы должны увидеть окно, в котором мы можем включить или выключить его указаны параметры ядра:
В моем ноутбуке установлен процессор Intel, но также был проверен ряд вариантов от процессоров AMD.Поэтому стоит пересмотреть уже выбранные варианты и скорректировать их.
Сборка ядра Linux
Когда мы закончим с конфигурацией, сохраняем ее и возвращаемся в терминал, где ее проводим следующую команду:
# сделать ARCH = "x86_64" -j2 bindeb-pkg Target bindeb-pkg соберет нам три файла: linux-image - *.deb , linux-headers - *.deb и linux-libc-dev_*.deb . Первые два уже могут быть установлены в системе, а последний обычно он будет конфликтовать с версией, которая была установлена в системе в силу права собственности ядро дистрибутива.Я еще не установил этот третий пакет, и система, кажется, действовать как следует.
Если вам нужно построить другие вещи, рекомендуется обратиться за помощью:
# сделать помощь Функциональность ядра, скомпилированная на жестком диске или в виде модуля
Ядро Linuxимеет множество опций, которые влияют на его функциональность при нормальной работе. компьютерная работа. Если бы все эти вещи были постоянно скомпилированы в ядро, оно было бы довольно большим. размеры и съели бы нам ценные ресурсы оперативной памяти.Поэтому ядра разных дистрибутивов Linux имеет целую кучу модулей, которые загружаются или могут быть загружены позже, когда это произойдет. такой необходимости, например, подключить к компьютеру новое USB-устройство.
Модулихороши при работе с ядром, которое должно работать на большом количестве оборудования, или когда некоторые устройства подключаются лишь изредка. Тем не менее все это функциональность ядра, необходимая для правильной работы нашей конкретной машины функционирование должно быть скомпилировано в постоянном режиме.Компилировать ли поддержку модема LTE постоянно, который мы используем, когда наше основное подключение к Интернету выходит из строя, каждый должен ответьте сами. То же самое относится и к другому оборудованию, которое мы не используем ни для чего. день.
По производительности практически нет разницы при компиляции какого-то кода постоянно сравнивать с модульным аналогом, по крайней мере, в плане эксплуатации, потому что в в случае с модулем нужно добавить некоторое время на его загрузку.
Размер ядра и образа initramfs/initrd
Далее сравнивается размер самого ядра и образа initramfs, загруженного в память сразу после запуска компьютера.
# ls -alh /boot/ | egrep "initrd | vmlinuz" -rw-r - r-- 1 root root 32M 2018-12-31 02:52:17 initrd.img-4.19.0-1-amd64 -rw-r - r-- 1 root root 9.9M 2019-01-01 16:58:10 initrd.img-4.19.13-amd64-morphic -rw-r - r-- 1 root root 5.0M 2018-12-30 10:04:03 vmlinuz-4.19.0-1-amd64 -rw-r-r-- 1 корень корень 8.4M 2019-01-01 16:46:34 vmlinuz-4.19.13-amd64-morphic Вышеуказанные файлы относятся к одному и тому же ядру, за исключением того, что файл с -morphic суффиксом был создан мной, а не людьми из дистрибутива Debian. Я встроил все функции ядро отвечает за корректную работу моего ноутбука постоянно. я сделал то же самое в для других устройств, которые я подключаю к нему время от времени.
Разумеется, вышеуказанные файлы сжаты и для сравнения их реальных размеров вам нужны эти файлы первая распаковка:
# /usr/src/linux-source-4.19/скрипты/extract-vmlinux/boot/vmlinuz-4.19.13-amd64-morphic> morphic-kernel # /usr/src/linux-source-4.19/scripts/extract-vmlinux /boot/vmlinuz-4.19.0-1-amd64> debian-kernel # ls -alh/tmp/kernel- * -rw-r -r-- 1 root root 27M 01.01.2019 18:45:01 /tmp/kernel-debiana -rw-r -r-- 1 root root 38M 01.01.2019 18:44:49 / tmp / morphic-kernel Хорошо видно, что мое ядро более чем на 40% больше ядра дистрибутива. Это не значит, что он будет кушать больше оперативной памяти - потому что это ядро дистрибутива должно делать загружать модули, которые были загружены на диск.
Что касается образа initramfs, то дело обстоит следующим образом:
# unmkinitramfs /boot/initrd.img-4.19.13-amd64-morphic/tmp/initramfs-morphic # unmkinitramfs /boot/initrd.img-4.19.0-1-amd64/tmp/initramfs-debiana # du -hm/tmp/initramfs- * 104 /tmp/initramfs-debiana/главная 2 /tmp/initramfs-debiana/начало 105 /tmp/initramfs-debian 21 /tmp/initramfs-morphic/основной 2 /tmp/initramfs-morphic/ранний 22 /tmp/initramfs-morphic Значения в первом столбце указаны в мегабайтах.Итак, вы можете видеть, что мой образ initramfs уже существует. намного меньше распределительного, так как в отличие от него не содержит всей массы ненужные модули. Конечно разница на уровне нескольких десятков мегабайт скорее в сегодняшних раз никто не будет проводить бессонные ночи. Так же, как загрузка модулей со свободного жесткого диска или даже быстрее SSD, потому что это вопрос нескольких или максимум нескольких секунд.
Какая функциональность ядра была скомпилирована.
После сброса машины она должна запуститься без особых проблем, если только не слишком вещи были отключены вручную.Пока мне удалось лишить свой ноутбук клавиатуры, звука, пакетный фильтр (iptables), а из-за неправильного выбора криптографических модулей я не смог Я расшифровываю свою систему, но теперь все эти вещи исправлены. Что, однако, может случиться сломать в самом начале это сервис systemd отвечающий за загрузку модулей при загрузке система. Поэтому стоит поинтересоваться, что у нас есть в каталоге /etc/modules-load.d/. Ошибки будет вызвано только отсутствием определенного модуля.Если такая функциональность ядра останется компилируется постоянно, система вернет только соответствующую информацию:
systemd-modules-load [582]: модуль «цикл» встроен Также следует помнить, что все встроенные модули больше не будут видны в lsmod или файл /proc/modules . Если мы хотим проверить, какая функциональность была встроена в ядро, и если есть модули, которые мы ожидаем, то мы можем просмотреть конфигурацию ядра:
#cat/boot/config -$(uname -r) #zcat/proc/config.гз Мы также можем посмотреть файл modules.builtin в каталоге модулей ядра:
#cat/lib/modules/$(uname -r)/modules.builtin Если вы компилируете все параметры ядра постоянно, также хорошо проверить у нас не было выживших:
# egrep \ = m /boot/config-4.19.13-amd64-morphic Если указанная выше команда завершается неудачей, все функции ядра сохраняются. постоянно компилируется в него.
Параметры постоянно компилируемых модулей
Если бы нам довелось настраивать параметры модуля, то нам лучше было бы ознакомиться с каталог /etc/modprobe.d/. Если модули постоянно скомпилированы, это конфигурация из этого каталога он нам просто не подойдет. Тем не менее, мы можем по-прежнему параметры модули различаются. Это просто нужно сделать через «командную строку ядра», которую мы можем выполнить за два способы.
Первый способ - отредактировать конфигурацию загрузчика, где у нас есть запись, аналогичная приведенной ниже:
... ДОБАВИТЬ root=/dev/mapper/wd_black_label-root... loop.max_part=63 ro ... Второй способ — указать соответствующую опцию в исходной конфигурации ядра:
Оба этих метода в основном похожи, потому что результирующая строка ядра видна под /proc/cmdline будут точно такими же, т.е. содержать те же параметры и те же ценности. Способ указания параметров в строке ядра следующий. Сначала мы определяем имя модуля, в данном случае это шлейф .Тогда мы даем . , который отделяет имя модуля от его параметр после точки, т.е. max_part . Этому параметру можно присвоить значение i поэтому за ним следует = , а желаемое значение равно 63 .
Итак, мы знаем, как настроить модуль, но где взять параметры модуля? Вы можете прочитать их из modinfo :
# цикл модинфо ... parm: max_loop: Максимальное количество петлевых устройств (целое) parm: max_part: Максимальное количество разделов на петлевое устройство (целое) Вы также можете использовать системный инструмент :
# systool -v -m цикл ... Параметры: макс_цикл = "0" макс_парт = "63" С помощью systool вы также можете увидеть текущую конфигурацию модуля.
Утилиты modinfo может нам помочь, только если у нас загружено ядро с модулей, т.е. мы еще не перешли на наше свежесваренное яйцо. Как только мы это сделаем, это modinfo вернет только ошибку, что модуль не найден:
# цикл модинфо modinfo: ОШИБКА: Цикл модуля не найден. Так что либо давайте использовать инструмент systool , либо вам нужно посмотреть каталог /sys/module/имя_модуля/параметры/.
Полностью отключить поддержку модулей
Когда мы собираемся полностью отказаться от модулей и скомпилировать весь нужный нам функционал ядро постоянно, у вас может возникнуть соблазн полностью отключить поддержку модулей ядра. Это может быть поддержано улучшением безопасности (никто больше не сможет использовать какие-либо модули load) и более простое в сборке ядро, что в свою очередь ускорит его работу.Однако, проверка CONFIG_MODULES вызывает у некоторых приложений проблемы с определением того, некоторые функции предлагаются ядром. Одним из таких приложений является containerd , который возвращает следующую ошибку:
modprobe: ОШИБКА: ../libkmod/libkmod.c:514 lookup_builtin_file() не удалось открыть встроенный файл '/lib/modules/4.19.13-amd64-morphic/modules.builtin.bin' modprobe: FATAL: оверлей модуля не найден в директории /lib/modules/4.19.13-amd64-морфный Все необходимые модули должны быть встроены в ядро, но из-за отсутствия файла modules.builtin.bin служба не встанет. Обычно достаточно заглянуть в сервисы звонков от modprobe и прокомментируйте его:
... [Обслуживание] # ExecStartPre=/sbin/modprobe оверлей ExecStart=/usr/bin/containerd ... То же самое касается службы systemd-modules-load.service , которая также не запустится и вернет ошибку.И эту услугу тоже надо отключить.
# маска systemctl systemd-modules-load.service Также стоит посмотреть файлы в директории /etc/initramfs-tools/ и проверить их на наличие возможные попытки загрузки модулей.
Хотя службы и конфигурацию системы можно легко улучшить, когда мы собираемся установить пакеты с *-dkms в имени, к сожалению полностью отключить поддержку модулей мы не можем, потому что механизм DKMS, наконец, создает модули, которые будут загружены, когда возникнет необходимость.
Отключение загрузки модулей во время работы системы
Если полное отключение модулей ядра вызывает у нас много проблем, вы можете воспользоваться менее инвазивным вариантом, который заключается в отключении возможности загрузки модулей во время работы система. Здесь достаточно установить только эту опцию в файле /etc/sysctl.conf :
ядро.modules_disabled = 1 Обратите внимание, однако, что kernel.modules_disabled защищает нас только с того момента, как мы установим это вариант - его нельзя изменить с 1 на 0 без перезагрузки системы.Тем не менее, это все еще неуклюже модули могут быть загружены при запуске системы.
Исправление ядра (патч)
Иногда встречаются интересные патчи ядра, которые по какой-то причине (иногда оправданной, т.е. они вызывают ОШИБКИ ядра) не применяются к ядру дистрибутива. Пример такого патча может быть TPE (выполнение доверенного пути). Если у вас есть собственное ядро, вы можете скачать такой патч и подать заявление. Процесс применения патчей может быть автоматическим или ручным, в зависимости от того, мы можем использовать одеяло 'а.
По умолчанию такой патч скачивается в каталог, где у нас есть и каталог ядра, т.е. w в данном случае это /usr/src/ затем переходит в каталог ядра и применяет патч к следующий метод:
# cd /usr/src/linux-4.19.12/ # patch --dry-run -p1 <../v2-1-1-Add-Trusted-Path-Execution-as-a-stackable-LSM.diff # patch -p1 <../v2-1-1-Add-Trusted-Path-Execution-as-a-stackable-LSM.diff А когда есть необходимость скачать патч делаем это с параметром -R :
# patch -R --dry-run -p1 <../v2-1-1-Add-Trusted-Path-Execution-as-a-stackable-LSM.diff # patch -R -p1 <../v2-1-1-Add-Trusted-Path-Execution-as-a-stackable-LSM.diff Если патч состоит из нескольких файлов, применяйте файлы в порядке номеров от наименьший. При загрузке такого патча делаем в обратном порядке, т.е. Загрузите последний файл, примененный первым.
Проблема с применением и поиском исправлений, подобных этому, заключается в том, что у нас нет никакого механизма отслеживание изменений, которые мы вносим в исходный код ядра.Когда у нас есть только несколько патчи, то такая ситуация для нас не будет большой проблемой, а вот если их много патчи, легко заблудиться. Так что вместо того, чтобы возиться с исправлениями вручную, это хорошая идея запаситесь стеганым одеялом . Этот инструмент может быть не установлен по умолчанию. Тоже как-то так их нужно установить:
# aptitude установить одеяло Создаем конфигурационный файл для quilt , т.е. /root/.quiltrc со следующим содержимым:
# кошка /root/.quiltrc экспортировать QUILT_PATCHES = "debian/патчи" экспорт QUILT_PUSH_ARGS = "- цвет = авто" экспорт QUILT_DIFF_ARGS = "- без временных меток --без индекса -p ab --color = авто" export QUILT_REFRESH_ARGS = "- без временных меток --без индекса -p ab" экспорт QUILT_DIFF_OPTS = '- p' Из приведенного выше файла нас больше всего интересует переменная $ QUILT_PATCHES , так как она определяет в каком каталоге будут патчи. Путь к каталогу указан относительно каталога рабочий, т.е.исходники ядра. При сборке пакета ядра для Debian он будет создан каталог debian/ (и ряд файлов в нем) в корневом каталоге исходного кода ядра. Если мы не хотим кладем патчи в debian/patches/, потом мы всегда можем удалить эту директорию и создать на ней поместите символическую ссылку, например, в каталог /usr/src/kernel-patches/:
# rmdir debian/патчи # ln -s /usr/src/kernel-patches/./debian/patches Таким образом, все исправления всегда будут находиться вне исходников ядра и через них. дело не будет удалено, когда мы удаляем старые источники.
Подготовив лоскутное одеяло , мы можем импортировать патч и применить его следующим образом:
# quilt import /path/to/file # лоскутное одеяло 
Загрузите патч следующим образом:
# лоскутное одеяло Если хотим скачать или применить сразу все патчи, даем:
# толкатель для одеяла # поп одеяло После применения исправлений, обычно в xconfig у нас будет еще несколько параметров для проверки.Если не хотим их искать (из-за этого глючит поиск), тогда можно вместо сделать xconfig давать делаем oldconfig , который нам расскажет все новые опции по сравнению с уже указанными в конфигурация.
Для верности еще можно посмотреть xconfig :
90 800
После применения патча ядро нужно снова скомпилировать. В зависимости от изменений, внесенных в конфигурация, перекомпиляция/компиляция могут затрагивать только часть кода ядра.Так что вам не нужно компилировать ядро с нуля с уже скомпилированными исходниками, если только не выйдет очистить . Поэтому, если мы лишь немного изменим конфигурацию ядра, то пакеты .deb с готовым к установке ядром мы можем сделать это очень быстро, если только не выйдет более новое версию ядра, то, к сожалению, компиляция начнется с нуля, и это может занять некоторое время моменты.
| LinuxExpert - блог Unix и Open Source
Основная информация
Что такое ядро?
Ядро системы обеспечивает взаимодействие между приложениями и компьютерным оборудованием. Отвечает за использование оперативной памяти, совместное использование процессора, запись и чтение из памяти большого объема (жесткие диски, компакт-диски) и т. д. В случае с Linux ядро системы создается сообществом программистов, сосредоточенным вокруг создателя, то есть Линус Торвальдс.
Что такое модули?
Ядро Linux состоит из монолитной части и модулей. Модули — это фрагменты исполняемого кода, обеспечивающие функциональную поддержку определенных элементов системы (например, принтер, сетевая карта, поддержка протокола PPP), которые по практическим причинам не обязательно постоянно присутствуют в ядре системы. Таким образом, мы получаем экономию за счет того, что имеется небольшое количество избыточного (т.е. ненужного) кода, снижающего скорость работы ядра. Пример: если у нас есть модемное подключение к Интернету, нет смысла постоянно держать протокол PPP в ядре.Достаточно загрузить его, когда это необходимо, т.е. запустить соединение, а затем, после завершения соединения, удалить его.
Версии ядра
Каждое ядро имеет номер в виде x.y.z, где x — номер версии, y — подверсия, а z — номер ревизии. На данный момент мы все используем версию 2. 2.5.x) версию разработки (так называемую версию разработки).Начиная с версии 2.6.0 это правило изменилось. Это было связано с необходимостью гораздо быстрее включать новые функции в код ядра. Начиная с этой версии многие исправления просто включались в последующие выпуски ядра. Однако у этого есть недостаток, новый код, который что-то исправляет или вводит новый функционал, часто содержит ошибки, нарушающие его стабильность.
Линус решил решить эту проблему следующим образом: Начиная с версии ядра 2.6.12, новые ядра будут делиться на "патч" и "разрабатываемые" ядра.Мы сможем распознать их по последнему номеру версии, четному (патч-ядро) или нечетному (разрабатываемое ядро). Конечно, в случае с последними при их использовании рекомендуется проявлять наибольшую осторожность…
Последняя стабильная версия ядра 6 (т.е. ядра с пометкой 2.6.x), однако есть установки, работающие на ядрах 2.2.x и даже 2.0.x. Это связано с тем, что многие администраторы работают по принципу зачем чинить то, что хорошо работает. Другое дело, что для некоторых устройств нет драйверов в новых версиях ядра (они больше не поддерживаются) или стоимость работ, необходимых для обновления ядра (а возможно и всей системы) до более новой версии, не выливается в рентабельность по функционалу ...
Пакетыс заголовками ядра
Некоторым приложениям, которые в своей работе обращаются непосредственно к ядру, требуется информация о том, как работает ядро (например,VMware для эмуляции виртуального компьютера). Для этого им требуется код ядра (а точнее, его файлы заголовков, где определены имена функций и переменных), чтобы определить, что доступно. Поскольку все ядро в данном случае слишком большое и избыточное (а оно занимает более нескольких сотен мегабайт), запакованы были только заголовочные файлы. Так что иногда достаточно установить сам пакет, а не все ядро…
Патчи для ядра
Линус Торвальдс решительно настроен на внесение любых изменений и значительных улучшений в код ядра.Не все согласны с ним и т.н. патчи ядра, написанные независимыми программистами для расширения или улучшения функциональности ядра. Примеры включают grsecurity (улучшение безопасности системы) или исправления xfs, обеспечивающие поддержку файловой системы XFS.
Ветви ядер
Помимо патчей ядра, существуют также отдельные ветки (разница между веткой ядра и патчем в размере и количестве твиков), которые запускаются независимыми разработчиками.Самая известная ветка версии 2.4 принадлежала Алану Коксу. Ее ценили за отточенность деталей и новаторство. Большинство его исправлений позже вошли в основную ветку ядра. Его патчи можно скачать с: www.kernel.org/pub/linux/kernel/people/alan
.Недавно Алан также начал поддерживать ядра 2.6 (доступны патчи, начиная с версии 2.6.8). Их можно скачать с того же адреса.
Ядра чистые и распределены разработчиками дистрибутива
Если мы хотим сами скомпилировать ядро, у нас есть два способа получить его код.Мы можем использовать ядра, предоставленные Линусом Торвальдсом или предоставленные разработчиками дистрибутива. Первый вариант предоставляет нам «чистый» код ядра, в то время как поставщики обычно поставляют его с большим количеством патчей, так что нам не нужно слишком много заморачиваться с патчем. Однако может случиться (это то, что иногда случалось с ядрами, поставляемыми с дистрибутивом Mandrake), что ядро отказывается компилироваться в результате применения слишком большого количества исправлений.
Обновление : для ядер, распространяемых с Mandrake 9.1 (kernel-source-2.4.21-0.13mdk версия), если мы скомпилируем ядро без изменения настроек по умолчанию, оно скомпилируется. В противном случае ядро не скомпилируется должным образом.
Получить исходники ядра
Если вы хотите использовать ядро, предоставленное Линусом Торвальдсом, загрузите последнюю версию с сайта www.kernel.org и распакуйте ее в каталог /usr/src/. Если вы хотите использовать версии дистрибутива, просто установите один из пакетов с именем kernel-source-kernel_version.
После получения кода ядра выполните (если этого не сделал скрипт установки пакета) символическую ссылку /usr/src/linux на каталог с версией ядра, с которой вы хотите работать. Это позволит некоторым программам получить доступ к текущей версии исходников системы (например, конфигуратору KDE). Команда будет выполнена:
ln -s /usr/src/linux-2.4.x /usr/linux/linux
, где x — номер версии.
Затем перейдите в каталог /usr/src/linux. Все, что описано ниже, если явно не указано иное, делается в этом каталоге.
Пропатченное ядро
Наклеить пластырь на яичко очень просто. Загрузите файл патча в каталог кода ядра, распакуйте его и выполните команду:
.патч -p1 <файл_патча
Компиляция ядра
Настроить параметры ядра
| Конфигуратор запущен командой make config | Самый старый конфигуратор (к счастью, редко используемый) — это консольный скрипт под названием make config .В этом случае настройка параметров заключается в ответах на последующие вопросы. Неудобство его использования состоит в необходимости ответить на несколько десятков или более сотни вопросов. Это невыносимо в долгосрочной перспективе. |
| Конфигуратор, запускаемый командой make menuconfig | При работе в консольном режиме лучше всего использовать команду make menuconfig , которая вызовет GUI в консольном режиме (см. рисунок справа).Здесь нам больше не нужно отвечать на отдельные вопросы. Мы можем отметить или снять отметку только с тех опций, которые нас интересуют. Каждый элемент имеет графику, определяющую, что он может быть включен в ядро. Если это [] (то есть квадратные скобки), элемент может быть только постоянно присоединен к ядру. Если же у нас есть <> (угловые скобки), то данный элемент также может быть модулем. Элементы, которые мы постоянно включаем в ядро, помечаются пробелом до тех пор, пока рядом с ним не появится звездочка, но если это должен быть модуль, мы должны поставить М в верхнем регистре.Элементы, не включенные в ядро, должны быть пустыми. |
| Конфигуратор запускается командой make xconfig | Когда мы используем графическую среду, лучше использовать make xconfig , она откроет панель графической конфигурации для среды X-window. |
| Пользователи KDE могут использовать конфигуратор, предоставленный в их среде.Мы можем найти его в Панели управления KDE в разделе «Система» (правда, тогда вам следует работать в среде от имени администратора, иначе у вас не будет необходимых прав для сохранения новых параметров конфигурации). |
Процедура сборки
После настройки ядра выдаем команду:
сделать отд
Это для определения зависимостей (отношений) между файлами. Другая команда:
очистить
Очистите исходный код от мусора, оставшегося от предыдущих сборок.И команда
сделать zImage
Позволяет скомпилировать ядро. Однако создавать их лучше командой
сделать bzImage
Потому что это позволит нам получить сжатое ядро. Итак, у нас уже есть скомпилированное ядро, которое находится в /usr/src/linux/arch/i386/boot/zImage или, если мы использовали команду bzImage, в /usr/src/linux/arch/i386/boot/bzImage. Теперь нам нужно скомпилировать модули. Делаем это командой
сделать модули
А потом установить их в /lib/modules/number.версия:
сделать модули_установить
Важно, чтобы все ранее скомпилированные модули были удалены из каталога /lib/modules/номер-версии перед запуском make modules_install. Это нужно делать только в том случае, если мы собираем ядро с таким же номером версии, как и у скомпилированного ранее. Например, если у вас уже есть ядро 2.4.18 и вы компилируете ядро той же версии, удалите каталог /lib/modules/2.4.18. Это защитит нас от перезаписи модулей и сообщения Unresolved symbol
Установка нового ядра
Теперь пришло время установить ядро.Действие очень простое, выдаем команду:
сделать установить
И в каталог /boot добавляется новое ядро, для него делается запись в /etc/lilo.conf и создаются любые другие необходимые файлы.
Помощь в процессе компиляции
кэш-память
Программа ccache позволяет кэшировать результаты компиляции программ, благодаря чему последующие компиляции одних и тех же элементов выполняются значительно быстрее. Программа включена в пакеты Debian.
Инструменты распространениядля помощи в компиляции ядра
Дебиан
В Debian есть специальная утилита, позволяющая выполнить процесс компиляции ядра (после выбора опции) одной командой и создать пакет из такого ядра.Затем этот пакет просто устанавливается. Затем просто перезагрузите компьютер и загрузитесь с новым ядром... Подробнее об этом инструменте можно узнать в разделе, посвященном Debian.
В Интернете
.Как настроить ядро Ubuntu (как)
Настройка ядра не для всех. Прежде чем пытаться что-либо из этого, помните, что это может сломать вашу систему.
Есть несколько причин, по которым вы хотите настроить ядро. Вы можете урезать ядро только до основных служб, особенно если вы используете сервер или выделенное устройство, для которого требуется только самое необходимое. Возможно, вам придется исправить ваше ядро, чтобы оно поддерживало оборудование, которое в настоящее время не поддерживается используемым вами ядром.
В этой статье не будет объяснено, как настроить ядро, как настроить текущее. У меня будет еще одна статья, объясняющая, как исправить ядро, и некоторые практические причины, по которым вы хотели бы это сделать.
Для начала нам нужно узнать, какая версия ядра работает в данный момент. Мы будем использовать команду uname
$ uname -r
2.6.17-10-generic
Теперь нам нужно установить исходный код Linux для вашего ядра, обратите внимание, что я использую ядро 2.6.17-10, поэтому строка установщика отражает это. Для целей этой статьи вы можете заменить номер ядра тем, что вы используете. Нам также нужно установить библиотеку curses и некоторые другие инструменты, которые помогут нам ее скомпилировать.
sudo apt-get install linux-source-2.6.17 пакет ядра libncurses5-dev fakeroot
Если вам интересно, откуда устанавливается исходный код Linux, вы можете использовать команду dpkg для передачи файлов в пакет для вас. Вот вывод в моей системе:
$ dpkg -L linux-source-2.6.17
/.
/usr
/usr/src
/usr/src/linux-source-2.6.17.tar.bz2
/usr/share
/usr/share/doc
/usr/share/doc/linux-source-2.6 .17
(усеченный)
Мы видим, что исходники были установлены в /usr/src в заархивированном файле.
Чтобы упростить задачу, мы перейдем в режим root, используя sudo для открытия новой оболочки. Есть и другие способы, но я предпочитаю этот.
sudo / bin / bash
Теперь измените каталог на исходный, чтобы мы могли установить.Обратите внимание, что вам может потребоваться установить bunzip, если он не установлен. (это было у меня)
cd / usr / src
bunzip2 linux-source-2.6.17.tar.bz2
tar xvf linux-source-2.6.17.tar
ln -s linux-source-2.6 .17 linux
Сделайте копию существующей конфигурации ядра, которая будет использоваться для пользовательского процесса сборки. Обратите внимание, что «символ тот, что под тильдой ~
cp/boot/config-'uname -r'/usr/src/linux/.config
Теперь мы запустим утилиту, которая позволит нам настроить ядро:
cd /usr/src/linux
create menuconfig
Сначала перейдите к Load Alternate Configuration File и загрузите файл .config . (просто нажмите Enter)
Теперь, когда мы находимся в инструменте, мы можем установить параметры для нашего пользовательского ядра. Навигация довольно простая, вверху есть легенда, если заблудитесь. Я выбрал «Сеть» и нажал клавишу «Ввод», чтобы попасть в эту категорию.
Поддержка радиолюбителей? На кой черт он установлен? Вы заметите, что * встроен в ядро.
Нажатием кнопки? key, мы видим справку по этому конкретному пункту. Вот объяснение:
Что ж, я его немедленно выключу. Почему он действительно установлен в моем ядре? Я нажал Esc, чтобы выйти из экрана справки, а затем нажал N, чтобы исключить это из моего ядра.
Когда вы закончите выбор, нажмите «Готово» и сохраните конфигурацию при появлении запроса.
Теперь у нас есть конфигурация, готовая к компиляции. Во-первых, мы сделаем чистку, чтобы убедиться, что все готово к компиляции.
make-kpkg clean
Далее мы собственно компилируем ядро. Это займет ДОЛГОЕ ВРЕМЯ, так что найдите что-нибудь интересное.
fakeroot make-kpkg -initrd -append-to-version=-custom kernel_image kernel_headers
Этот процесс создаст в /usr/src два файла .deb, содержащие ядро.Файл linux-image **** является фактическим образом ядра, а другой файл можно установить как из dpkg. Имена файлов, скорее всего, будут другими в вашей системе.
Обратите внимание, что при выполнении любых последующих команд это новое ядро будет установлено в качестве нового ядра по умолчанию. Он может сломать вещи! Если ваша машина не загружается, вы можете нажать Esc в меню загрузки GRUB и выбрать свое старое ядро. Затем вы можете отключить ядро в /boot/grub/menu.lst или повторить попытку компиляции.
dpkg -i linux-image-2.6.17.14-ubuntu1-custom_2.6.17.14-ubuntu1-custom-10.00.Custom_i386.deb
dpkg -i linux-headers-2.6.17.14-ubuntu1-custom_2.6.17.14-ubuntu1-custom-10.00.Custom_i386 deb
Теперь перезагрузите компьютер. Если все работает, вы должны загрузить свое новое пользовательское ядро. Вы можете проверить это, используя uname. Обратите внимание, что точное число на вашем компьютере будет другим.
uname -r
2.6.17.14-ubuntu1-custom
Я планирую написать серию статей о настройке ядра, так что подпишитесь на RSS-канал для получения обновлений.
Кроме того, в интересах полного раскрытия информации я узнал, как это сделать, из статьи на HowtoForge, который является отличным сайтом для очень продвинутых руководств по Linux. Вы заметите, что многие шаги в этой статье похожи, хотя я попытался сделать эту статью более «убунту».
.Руководство по установкеLinux на встроенную платформу • FORBOT
- Блог
- Статьи
- Программирование
- Linux
- Руководство по установке Linux на встроенной платформе
В первой части статьи я описал возможность использования дешевого нетбука в качестве контроллера робота. Как было объявлено в следующем посте, я представляю инструкции по установке Linux на выбранную предыдущую платформу.
Для дальнейшей работы вам потребуются: загрузчик, ядро linux, файловая система и компилятор (тулчейн).
«Предыдущая статья в серииСледующая статья в серии»
В случае с Raspberry Pi мы могли бы загрузить все это в виде готового дистрибутива (например, Raspbian). При использовании нетбука нам приходится готовить все с нуля. Мы начнем с конца, то есть с компилятора и файловой системы .
Препараты
Для начала вам понадобится компьютер (ПК, ноутбук) с установленным linux.Вы можете использовать другую систему (например, Windows или Mac OS), но тогда все будет намного сложнее.
тоже не рекомендую использовать виртуальные машины - долго компилируется, а в виртуалке уйдёт в несколько раз больше.
Так что стоит постараться обзавестись быстрым компьютером и большим количеством свободного места на диске (минимум 20гб, лучше зарезервировать еще больше места). Я использую дистрибутив Ubuntu 14.04 LTS , но можно использовать практически любую популярную версию.Вам также понадобится доступ в Интернет, желательно быстрый.
Первая сборка
У нас есть первый доступный в системе кросс-компилятор. Все, что нам нужно сделать, это установить его:
sudo apt-get установить gcc-arm-linux-gnueabi
| sudo apt-get установить gcc-arm-linux-gnueabi |
Мы можем проверить, работает ли это:
arm-linux-gnueabi-gcc — версия
| arm-linux-gnueabi-gcc — версия |
Получаем сообщение:
arm-linux-gnueabi-gcc (Ubuntu/Linaro 4.7.3-12убунту1) 4.7.3 Авторское право © 2012 Free Software Foundation, Inc. Это бесплатное программное обеспечение; см. источник условий копирования. Здесь нет гарантия; даже не для КОММЕРЧЕСКОЙ ПРИГОДНОСТИ или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ.
| arm-linux-gnueabi-gcc (Ubuntu / Linaro 4.7.3-12ubuntu1) 4.7.3 Copyright © 2012 Free Software Foundation, Inc. Это бесплатное программное обеспечение; см. источник условий копирования.НЕТ гарантии ; даже не для КОММЕРЧЕСКОЙ ПРИГОДНОСТИ или ПРИГОДНОСТИ ДЛЯ ОПРЕДЕЛЕННОЙ ЦЕЛИ. |
Если нам лень, можно и на этом остановиться. Компилятор работает как обычный gcc , разница только в префиксе " arm-linux-gnueabi-". Это немного длинно, но именно так обычно называют кросс-компиляторы. Позже вы обнаружите, что это весьма полезно, потому что на одной и той же машине может быть много разных версий gcc.Выбранная версия компилирует программу C в форму, предназначенную для для процессоров ARM.
Мы можем использовать его для компиляции ядра. Однако начнем мы с файловой системы.
Linux состоит из двух основных частей:
Каждый, кто имел дело с Linux, знает характерное расположение каталогов:
Содержимое этих каталогов должно быть подготовлено и оснащено файлами, совместимыми с используемым процессором. К счастью, есть готовые инструменты, которые нам в этом помогут.Мы будем использовать Buildroot — простой в использовании, но довольно мощный инструмент, который будет «собирать» наш линукс. Код скачивается с сайта проекта: http://buildroot.uclibc.org/
Самый простой способ использовать git (конечно его нужно установить: sudo apt-get install git ). С помощью приведенной ниже команды мы загружаем все на наш компьютер.
git клон git: //git.buildroot.net/buildroot
| git clone git: // git.buildroot.net/buildroot |
Сам билдрут относительно небольшой, только потом разрастется (у меня занимает 10гб). Заходим в каталог buildroot и выдаем команду:
Если вы еще не устанавливали библиотеку ncurses, ее необходимо установить быстро:
sudo apt-получить libncurses5-dev
| sudo apt-get libncurses5-dev |
Мы должны увидеть меню программы:
Если кому-то очень не нравится текстовый режим, он может ввести команду:
сделать xconfig или сделать gconfig
| сделать xconfig или сделать gconfig |
Пока установлены все необходимые библиотеки (qt или gtk), мы увидим окружение рабочего стола.Однако их содержания абсолютно одинаковы. Какой вариант мы выберем, зависит от наших предпочтений.
С помощью меню выбираем, какие параметры будут у нашего линукса, после чего сохраняем конфигурацию выходом. Он будет сохранен в (скрытом) файле с именем ".config" .
Следующим шагом будет команда:
и долгий перерыв на кофе.
Компиляция может занять до нескольких часов!
Первые попытки могут быть неудачными.Затем вы должны прочитать сообщения об ошибках. Чаще всего ошибки возникают из-за отсутствия установленных надлежащих библиотек. Вы должны установить эти библиотеки и начать заново.
В приложении к статье есть готовый .config файл с конфигурацией. Вы можете скопировать его и начать с этой версии.
Что выбрать:
- Целевые параметры → Целевая архитектура — выберите ARM (с прямым порядком байтов) Варианты цели
- → Вариант целевой архитектуры — cortex-A9, который является нашим процессором .
- Target options → Target ABI → EABIhf — если процессор имеет аппаратную поддержку чисел с плавающей запятой, hf позволит вам использовать сопроцессор
- Toolchain → библиотека C → eglibc — стандартная версия C.Есть uClibc - очень маленькая версия, glibc - версия для ПК, полная и eglibc - немного урезанная, но вполне достаточная для наших нужд
- Toolchain → Build cross gdb для хоста — выбор этой опции автоматически подготовит отладчик для нашей цепочки инструментов
- Toolchain → Регистрация набора инструментов в подключаемом модуле Eclipse Buildroot — позволяет легко интегрировать набор инструментов со средой Eclipse .
Целевые пакеты - в этом меню выбираем какие пакеты будут в нашей Linux версии.Я рекомендую:
- Игры → PrBoom - нет ничего лучше, чем играть в Doom на роботе ;-)
- Аудио и видео приложения → alsa-utils - если хотим запустить звук
- Аудио и видео приложения → madplay - мп3 плеер всегда пригодится
- Отладка, профилирование и бенчмаркинг → gdb, gdbserver - понадобится позже для работы отладчика
- Libraries → Graphics → opencv — пожалуй, самое главное, если мы хотим использовать плату робототехники
Как видите, есть еще довольно много пакетов, с которыми мы можем (позже) поиграться. После настройки системы соберите образ с помощью make . Buildroot сам скачает соответствующие пакеты, скомпилирует их и скопирует файлы в нужное место.
В первый раз это займет некоторое время, но мы уже видим результат. В выходном каталоге будут интересующие нас подкаталоги:
- хост - здесь можно найти инструменты используемые на ПК, в частности "наш" кросс-компилятор
- изображений - rootfs.tar содержит образ Linux , готовый к загрузке
Сборка ядра
В моем нетбуке установлен процессор WonderMedia . Теоретически каждый производитель обязан предоставить исходный код Linux или Android — лицензия GPL обязывает. С этим не всегда просто, к счастью, мы можем получить соответствующий код для этого процессора.
Получаем из репозитория git:
git клон https://github.com/wondermedia/wm8850
| git-клон https://github.com/wondermedia/wm8850 |
Компиляция проста. Заходим в директорию и компилируем:
сделать чистым сделать Android_defconfig делать делать модули сделать modules_install
| make clean make Android_defconfig make make modules make modules_install |
Если не работает (!) , сообщая об отсутствии arm-linux-gcc, редактируем Makefile и меняем префикс на наш, скачанный ранее:
CROSS_COMPILE?= Arm-linux-gnuueabi-
| CROSS_COMPILE?= Arm-linux-gnueabi- |
Теперь все должно работать нормально.Компиляция снова займет некоторое время, мы должны получить образ ядра - это файл: uzImage.bin (в каталоге ANDROID_3.0.8). Модули ядра будут скопированы в каталог out.
Теперь у нас есть практически все: ядро Linux, файловая система, набор инструментов. Нам не нужно беспокоиться о загрузчике — он уже установлен, а так как его кода у нас нет, то нужно использовать только готовый.
Следующий шаг - перенос файлов на плату с нетбука. Линукс можно залить на флэш-память, можно через ethernet (очень удобно при создании софта) или использовать SD-карту.Первый вариант потребует удаления Android, который жалко выбрасывать полностью (сначала нужно сделать резервную копию!). Второй вариант немного сложнее, у нас остается SD-карта.
SD-карта
Для работы с linux нужна карта с двумя разделами (как для RaspberryPi):
- Первый раздел FAT, образ ядра (файл uzImage.bin)
- второй раздел ext3 с нашей файловой системой linux
На своем компьютере я подключил SD-карту через внешний ридер.Он виден как устройство /dev/sde — это нужно настроить под свою конфигурацию.
Запускаем программу fdisk командой:
Интерфейс не очень дружелюбный, но инструмент очень функциональный. Сначала проверяем, какие разделы уже есть на карте командой «p» и удаляем их командой «d». Карта должна быть пустой:
Создаем первый раздел:
Команда (m для справки): n Выберите (по умолчанию p): p Номер раздела (1-4, по умолчанию 1): 1 Первый сектор (2048-x, по умолчанию 2048): Использование значения по умолчанию 2048 Последний сектор, + секторы или + размер {K, M, G}: + 512M
| Команда (m для справки): n Выбор (по умолчанию p): p Номер раздела (1-4, по умолчанию 1): 1 Первый сектор (2048-x, по умолчанию 2048): Использование по умолчанию значение 2048 Последний сектор, + секторы или + размер {K, M, G}: + 512M |
и следующий:
Команда (m для справки): n Выберите (по умолчанию p): p Номер раздела (1-4, по умолчанию 1): 2 Первый сектор (1050624-x, по умолчанию 1050624): Использование значения по умолчанию 1050624 Последний сектор, + секторы или + размер {K, M, G}:
| Команда (m для справки): n Выбор (по умолчанию p): p Номер раздела (1-4, по умолчанию 1): 2 Первый сектор (1050624-x, по умолчанию 1050624): Использование по умолчанию значение 1050 624 Последний сектор, + секторы или + размер {K, M, G}: |
Должно быть создано два раздела, в этом мы можем убедиться, выполнив команду "p".Мы также видим, что оба раздела имеют тип Linux, нам нужно изменить первый на FAT.
Команда (m для помощи): t Номер раздела (1-4): 1 Шестнадцатеричный код (напечатайте L для списка кодов): 6
| Команда (m для справки): t Номер раздела (1-4): 1 Шестнадцатеричный код (наберите L для списка кодов): 6 |
Разделы подготовлены, осталось выйти из программы и сохранить результаты.Для этого используется команда «w». Пришло время форматировать разделы. Во-первых, форматируется в системе FAT:
.sudo mkfs.fat /dev/sde1 -n ЯДРО
| sudo mkfs.fat /dev/sde1 -n ЯДРО |
Затем вторая система ext3:
sudo mkfs.ext3 /dev/sde2 -L linuxfs
| судо мкфс.ext3/dev/sde2 -L linuxfs |
Теперь мы можем скопировать необходимые файлы. Просто копируем файл uzImage.bin на первый раздел. Во-вторых, нам нужно распаковать файл rootfs.gz . Заходим в директорию buildroot/output/images и выдаем команду:
sudo tar -C
| sudo tar -C |
для меня будет команда:
cd buildroot/выход/изображения sudo tar -C/media/elvis/linuxfs/-xf rootfs.tar
| cd buildroot/output/images sudo tar -C/media/elvis/linuxfs/-xf rootfs.tar |
При компиляции ядра в каталоге out были подготовлены модули - также копируем их на карту.Просто скопируйте каталог lib с его содержимым в файлы изображений.
Не забудьте "вежливо" размонтировать карту (запись может быть отложена, так что это занимает некоторое время), на всякий случай я всегда выполняю команду "sync", которая принудительно выполняет физическую запись на носитель. У нас есть все необходимое для запуска Linux на борту.
Загрузчик
Вставьте sd карту в разъем на плате и подключите питание (если она уже была подключена, нажмите ресет - как хорошо, что производитель разместил кнопку на плате).Если ничего не делать, запустится Android, сохраненный во Flash-памяти. Это хорошо, мы всегда сможем использовать его снова.
Чтобы загрузить нашу систему, нам нужно прервать загрузку.
Для этого просто нажмите ENTER.
Мы должны получить следующий эффект:
На экране нетбука появится значок Android, но загрузка будет прервана . То, что мы видим, это uboot, один из стандартных загрузчиков. Если нам нужна помощь, мы можем ввести команду help или ? .
Там будут все доступные команды с кратким описанием, uboot достаточно мощный инструмент, тема для отдельной статьи. Сейчас мы просто хотим запустить Linux. Копируем следующую команду и вставляем в окно терминала:
setenv bootargs 'mem = 447M root = /dev/mmcblk0p2 rw console = ttyS0,115200n8'; инициализация ммк; жирная загрузка mmc 0 0x00E00000 uzImage.bin; загрузка 0x00E00000
| setenv bootargs 'mem = 447M root = /dev/mmcblk0p2 rw console = ttyS0,115200n8'; инициализация ммк; жирная нагрузка mmc 0 0x00E00000 uzImage.корзина; загрузка 0x00E00000 |
Через несколько секунд Linux готов к работе:
Войдите в систему как root, пароль по умолчанию пуст. Можем посмотреть наши жестко подготовленные файлы, просмотреть систему. А когда у вас появится свободное время, введите:
/usr/games/prboom -width 800
| /usr/games/prboom-ширина 800 |
Веселись!
Время перерыва!
«Предыдущая статья в серииСледующая статья в серии»
Вложения
Файл.конфиг (zip, 10 КБ)
Статья была интересной?
Присоединяйтесь к 11 000 человек, которые получают уведомления о новых статьях! Зарегистрируйтесь и вы получите PDF-файлы с шпаргалками (в том числе по мощности, транзисторам, диодам и схемам) и списком вдохновляющих DIY на основе Arduino и Raspberry Pi.
Это еще не конец, также проверьте
Читать похожие статьи и популярные в настоящее время записи или рандомизировать другую статью »
android, встроенный, linux, нетбук
.Установка ядра Linux 5.16 / 5.17 в Fedora Linux 34/35 — поддержка Linux
Ядро Linux 5.16 имеет много новых функций, поддержку и безопасность. Выпуск ядра Linux 5.16 имеет замечательную новую функцию FUTEX2 или futex_watv (), , которая предназначена для улучшения игрового процесса Linux и значительно расширяется благодаря улучшенному портированию Linux для игр Windows с использованием Wine.
Другие усовершенствования улучшили запись Congestion Management Task Scheduler для кластеров процессоров, совместно использующих кэш L2 / L3, среди прочего.Дополнительные сведения см. в журнале изменений ядра версии Linux 5.16 .
В следующем руководстве вы узнаете, как установить последнюю версию ядра Linux 5.16/5.17 на сервер Fedora 34/35 или рабочую станцию , используя хорошо известный сторонний репозиторий Linux Vanilla.
Предпосылки
- Рекомендуемая ОС: FedoraLinux 35.
- Учетная запись пользователя: Учетная запись пользователя с доступом sudo или root.
- Доступ в Интернет
- Архитектура ЦП:
В учебном пособии будет использоваться терминал, который можно найти в меню демонстрационных приложений.
Пример:
Обновить операционную систему
Обновите операционную систему Fedora , чтобы убедиться, что все существующие пакеты обновлены:
обновление sudo dnf --refresh -y В учебнике будут использоваться команды от sudo до , если у вас есть статус sudo .
Чтобы проверить статус sudo вашей учетной записи:
Судо Вуами Пример вывода, показывающий статус sudo:
[джошуа @ fedora ~] $ sudo whoami корень Чтобы настроить существующую или новую учетную запись sudo, посетите наш учебник Добавление пользователя в Sudoers в Fedora .
Чтобы использовать учетную запись root , используйте следующую команду с паролем root для входа в систему.
к Требуется зависимость установки
Перед продолжением установки выполните следующую команду, чтобы убедиться, что следующие пакеты установлены.
sudo dnf установить dnf-plugins-core curl -y Импорт репозитория ядра Linux Vanilla
Fedora часто обновляется с последними стабильными ядрами. Обычно вы можете найти обновленные ядра из Fedora в тестовом или необработанном репозитории для будущих ядер, но они не выпускаются в одночасье, даже по стандартам Fedora.
Для пользователей, которые хотели бы более быстрого восстановления RPM и не использовать альтернативные ядра XanMod или Liquorix или компилировать свои собственные, что может быть слишком сложным или трудоемким для некоторых, Linux Vanilla rep часто обновляется со стабильной и основные ядра и хорошо известны.
Чтобы импортировать репозиторий в систему Fedora 35, используйте следующую команду.
curl -s https://repos.fedorapeople.org/repos/thl/kernel-vanilla.repo | sudo тройник /etc/yum.repos.d/kernel-vanilla.repo Установите ядро Linux 5.16 на Fedora
В настоящее время ядро Linux 5.16 находится в стабильной ветке. Чтобы начать установку, используйте следующую команду.
sudo dnf config-manager --set-enabled ядро-ваниль-стабильная Чтобы установить для стабильного репозитория более высокий приоритет, чем для репозитория ядра по умолчанию, используйте следующую команду.
sudo dnf config-manager --save --setopt = "ядро-ваниль-стабильный.приоритет = 99 " Подтвердите добавление приоритета.
grep приоритет /etc/yum.repos.d/kernel-vanilla.repo Пример вывода:
приоритет = 99 Ни один из других репозиториев не должен быть приоритетным, чтобы вы знали, что конфигурация репозитория прошла успешно, если она присутствует.
Теперь установите/обновите ядро Linux.
ядро обновления sudo dnf * --refresh Пример вывода:
Введите Y, , затем нажмите КНОПКА ВВОДА продолжить.
По завершении перезапустите систему.
перезагрузка судо По возвращении проверьте установленную версию ядра.
кат/проц/версия Пример вывода:
Поздравляем, вы установили самое последнее ядро Linux 5.16.
Установите ядро Linux 5.17 на Fedora
ВНИМАНИЕ, ЭТО ЯДРО ВСЕ ЕЩЕ В РЕЖИМЕ RC/РАЗРАБОТКИ, БУДЬТЕ ГОТОВЫ К БОЛЕЕ 5 ОШИБКАМ.16,90 179
Для тех, кто хочет жить на периферии, Основной репозиторий Linux Vanilla содержит последние основные сборки, которые в настоящее время могут похвастаться последним кандидатом на выпуск, 5.17, а также 5.18, 5.19 и т. д.
Теперь, если вы включили kernel-vanilla-stable для ядра Linux 5.16, отключите его.
sudo dnf config-manager --set-disable ядро-ванильное стабильное Теперь включите kernel-vanilla-mainline .
sudo dnf config-manager --set-enabled kernel-vanilla-mainline Установите для нового репозитория ядра более высокий приоритет, чем для любого другого репозитория.
sudo dnf config-manager --save --setopt = "kernel-vanilla-mainline.priority = 99" Теперь установите/обновите ядро Linux.
ядро обновления sudo dnf * --refresh Пример вывода:
Введите Y, , затем нажмите КНОПКА ВВОДА продолжить.
По завершении перезапустите систему.
перезагрузка судо По возвращении проверьте установленную версию ядра.
кат/проц/версия Пример вывода:
Поздравляем, вы установили последнее ядро Linux 5.17.
Альтернативный метод для ядра Linux 5.17
Для тех, кто хочет использовать необработанную версию ядра Fedora, посетите Как установить ядро Linux 5.17 в Fedora 35?.
Как восстановить ядро Fedora по умолчанию?
Следующие шаги покажут вам, как удалить установленное стороннее ядро и восстановить ядро Fedora по умолчанию. Могут быть и другие альтернативные способы, и этот метод будет работать, как показано ниже.
Сначала отключите включенный репозиторий Linux Vanilla.
Отключить ванильное ядро Linux 5.16:
sudo dnf config-manager --set-disable ядро-ванильное стабильное Отключить ванильное ядро Linux 5.17:
sudo dnf config-manager --set-disable kernel-vanilla-mainline Затем удалите репозиторий Linux Vanilla.
sudo rm /etc/yum.repos.d/kernel-vanilla.repo Далее перечислите ядра, присутствующие в Fedora.
ядро списка dnf Пример вывода:
В учебнике установлены версии 5.16 и 5.17 ядра Vanilla.
Используйте следующую команду, чтобы удалить оба и вернуться к ядру Fedora по умолчанию.
ВНИМАНИЕ! НЕ ЗАПУСКАТЬ ПОСЛЕ УДАЛЕНИЯ. ВЫ ДОЛЖНЫ ПЕРЕУСТАНОВИТЬ ЯДРО ПО УМОЛЧАНИЮ.
sudo dnf --setopt = protected_packages = удалить $ (rpm -q kernel-core | grep -v $ (uname -r)) Затем переустановите ядро Fedora .
sudo dnf установить ядро заголовки ядра модули ядра дополнительные модули ядра Пример вывода:
Введите Y , затем нажмите КНОПКА ВВОДА продолжить.
Затем перезагрузите систему.
перезагрузка судо После повторного входа проверьте установленное ядро, снова запустив cat.
кат/проц/версия Пример вывода:
Еще одна хорошая команда для запуска дистрибутива . Эта команда удобна для удаления больших пакетов или пакетов на базовом уровне, таких как ядра, и восстановления работоспособности вашей системы Fedora.
sudo dnf distro-sync -y В этом руководстве вы узнали, как установить последнюю версию ядра Linux 5.16/5.17 на сервер или рабочую станцию Fedora 34/35. В настоящее время Fedora 34 скоро станет EOL, поэтому поддержка ядра Linux Vanilla прекратится после выпуска Fedora 36; Помните это.
Хотите автоматические обновления? Подпишитесь на нас в одном из наших аккаунтов в социальных сетях!
.[PDF] Руководство по тестированию ядра Linux
1 Руководство по тестированию ядра Linux (версия 0.2) Михал Пиотровски Группа тестировщиков Linux Соавторы: Мацей Рутецкий ...
Руководство по тестированию ядра Linux (версия 0.2) Михал Пиотровски [электронная почта защищена] Группа тестировщиков Linux Соавторы: Мацей Рутецкий [адрес электронной почты защищен] Unixy.pl Рафал Й. Высоцкий [адрес электронной почты защищен]Люди, оказавшие влияние на учебник: Бартломей Жолнеркевич [адрес электронной почты protected ] Jarek Popławski [email protected] Mariusz Kozłowski [email protected]
II
Содержание I
Основы
1 Ядро, патчи, деревья и компиляция 1.1 ядро. . . . . . . . . . . . . . . . . 1.2 Патчи. . . . . . . . . . . . . . . . . 1.3 Кетчуп. . . . . . . . . . . . . . . 1.4 Деревья. . . . . . . . . . . . . . . . 1,5 Дерево -мм. . . . . . . . . . . . . 1.6 Сборка, подготовка системы
1. . . . . .
3 3 3 5 7 8 8
. . . . . .
15 15 15 17 18 19 22
3 Регистрация ошибок 3.1 Последовательная консоль. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3.2 Веб-консоль.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
25 25 26
4 Git, 4.1 4.2 4.3 4.4 4.5 4.6
29 29 31 32 32 34 35
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . тест
2 Тестирование 2.1 "Фаза 1". . . . . . . . . . . . . . . . . . . . . 2.2 «Этап 2 (Автотест)». . . . . . . . . . . . . . 2.3 «Этап 3». . . . . . . . . . . . . . . . . . . . . 2.4 Измерение производительности. . . . . . . . . . . . . . . 2.5 Привет, мир, что именно мы ищем? 2.6 Бинарные драйверы и ядра дистрибутива. . .
quilt и бинарный поиск Git. . . . . . . . . . . . . . . . . . . . . . . Одеяло. . . . . . . . . . . . . . . . . . . . . . Бинарный поиск - идея. . . . . . . . Стеганый бинарный поиск. . . Бинарный поиск с помощью git-bisect Остерегайтесь «make oldconfig». . . . . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
.. . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. .. . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
. . .. . .
. . . . . .
. . . . . .
. . . . . .
. . . . . .
5 Сообщения об ошибках
37
6 Тестирование оборудования
39
A Приложение A A.1 Отправка исправлений. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . А.2 Испытательная система. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
41 41 42
III
IV
СОДЕРЖАНИЕ A.3 KLive. . .. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . A.4 Как мне стать разработчиком Linux? . . . . . . . . . . . . . . . . . . . . . . . .
B Приложение B B.1 Как я могу помочь в дальнейшей разработке руководства? . . . . . . . . B.2 Где я могу получить помощь в тестировании? . . . . . . . . . . . . B.3 Немного о группе тестировщиков Linux. . . . . . . . . . . . . . . . B.4 Причины распространения ошибок на стабильные версии Linux B.5 Лицензия. . . . . . . . . . . . . . . . . . . . . . . . . . . .
.. . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
. . . . .
43 43 45 45 45 45 46 49
Введение Тестирование программного обеспечения играет очень важную роль в процессе разработки программного обеспечения. Это руководство предназначено для ознакомления читателя с процессом тестирования ядра Linux. Он разделен на несколько коротких глав, охватывающих более важные вопросы, которые должен знать каждый хороший тестировщик.Я не описываю подробно все проблемы, с которыми можно столкнуться при тестировании, чтобы не утомлять читателя, и оставить место для собственных открытий. Зачем вам утруждать себя тестированием ядра Linux? «Ну, на мой взгляд, мы должны протестировать их, если мы хотим быть уверены, что следующие версии ядра будут правильно работать на нашем оборудовании и будут правильно делать то, что нам нужно. Другими словами, если мы хотим «серьезно» использовать Linux, стоит потратить некоторое время на проверку того, есть ли в следующей версии что-то «заготовленное», что сломает наши шаблоны, тем более что ядро довольно существенно меняется между «стабильной» и «стабильной» версиями. версий (о которых большинство пользователей даже не подозревают).По сути, это обязанность пользователя с открытым исходным кодом: проверять наличие новых версий и сообщать о проблемах. Если мы этого не делаем, то мы не имеем права потом жаловаться, что что-то перестало работать. Конечно, от нашего тестирования выиграют и другие пользователи, но не стоит рассчитывать на то, что кто-то проверит за нас, будет ли новая версия ядра работать корректно или нет на нашем железе. :-) ”- Rafał J. Wysocki К сожалению, среди пользователей Linux существует миф о том, что люди, желающие протестировать ядро, должны уметь программировать.Такое утверждение столь же верно, как и утверждение, что люди, которые летают на новых моделях самолетов, должны уметь их проектировать. Навыки программирования очень полезны при выполнении тестов, они позволяют лучше оценить ситуацию и позволяют узнать о том, как работает ядро, но отсутствие этого навыка не лишает нас права тестировщиков. Мы должны иметь знания об устройстве и принципе работы операционной системы. Я рекомендую прочитать "Сборка операционной системы Linux 2.0" http://rainbow.mimuw.edu.pl/SO/Linux/ (исследование устарело, но очень подходит в качестве введения), «Драйверы устройств Linux» Джонатана Корбета, Алессандро Рубини и Грега КроаХартмана http://lwn.net/Kernel/ LDD3/ и "Linux Kernel Development" Роберта Лава http://rlove.org/kernel_book/ (на сайте KernelNewbies вы можете найти список всех 1
2
СОДЕРЖАНИЕ
интересных книг http://kernelnewbies. org/Кернелбукс). Очень полезные статьи о том, как работают некоторые компоненты ядра Linux, можно найти на Linux Weekly News http://lwn.net/Kernel/Index/(англ.). Однако следует помнить, что никакая книга или статья, даже самая лучшая, не заменит чтение исходного кода ядра единственной всегда актуальной документации. Еще один распространенный миф гласит: «используя разрабатываемые версии системы, мы рискуем потерять данные». Это абсолютно верно, как и «используя кухонный нож, мы рискуем лишиться пальцев». Чтобы устранить потерю данных, лучше всего выполнять тесты на выделенной системе, установленной на отдельном разделе, или на диске, на котором вы не монтируете какие-либо разделы из стабильной системы.Также рекомендуется регулярно делать резервные копии наших данных (это также очень хорошая практика на системах, которые считаются стабильными).
Часть I Основы
1
Глава 1 Ядро, исправления, деревья и сборка 1.1
Ядро
Вы можете скачать текущую версию ядра из «Архивы ядра Linux» http: // www. kernel.org/ в виде большого tar-архива, сжатого с помощью gzip или bzip2 (обратите внимание, что файлы bz2 меньше, чем gz).Архив нужно распаковать в какую-нибудь директорию (по умолчанию /usr/src/), это можно сделать несколькими способами (прелесть Unix-систем), мой любимый: $tar xjvf linux-2.6.x.y.tar.bz2 - файлы сжатый с помощью bzip2 $ tar xzvf linux-2.6.x.y.tar.gz - файлы, сжатые gzip Мы могли бы также следовать инструкциям в файле README $ bzip2 -dc linux-2.6.x.y.tar.bz2 | tar xvf $ gzip -cd linux-2.6.x.y.tar.gz | tar xvf После распаковки исходного кода ядра мы получаем каталог с названием его версии (например,linux-2.6.18), содержимое которого часто называют «деревом ядра». По этой причине слово «дерево» иногда используется для обозначения различных версий исходного кода ядра. Например, вместо того, чтобы говорить «версия исходных текстов ядра Эндрю Мортона», удобнее говорить «дерево -mm».
1.2
Патчи
Для обновления исходников не нужно скачивать весь архив, быстрее скачать патч. Применяем его внутри системной директории с исходниками: $bzip2 -cd/path/to/patch-2.6.x.bz2 | patch -p1 $ gzip -cd /path/do/patch-2.6.x.gz | patch -p1 или $ patch -p1
4
ГЛАВА 1. ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ
$ bzip2 -cd / path /do/patch-2.6.x.bz2 | patch -p1 -R Мы также можем проверить правильность применения исправления (без отброшенных фрагментов кода), используя флаг пробного запуска $ bzip2 -cd /path/do/patch-2.6.x.bz2 | patch -p1 --dry-run Если мы не заметили каких-либо сообщений "1 из 1 фрагмента FAILED - сохранение отклонений в файл *", пожалуйста, не стесняйтесь применять патч.Разумеется, после применения патчей мы получаем дерево ядра, отличное от того, которое было у нас в начале. Следовательно, дерево, с которого мы начинаем патчить, часто называют необработанным или ванильным деревом. Большинство различных версий исходного кода ядра, деревьев ядра, доступны в виде наборов исправлений или даже в виде отдельных исправлений, применяемых к соответствующей "сырой" версии ядра, доступной на ftp://ftp.kernel.org. Стабильные версии ядра отмечены цифрой 2.6.x или 2.6.x.y версии для разработки помечены как 2.6.x-git*, 2.6.x-rc* и 2.6.x-rc*-git*. Такой способ маркировки позволяет легко узнать, какие патчи нужно применить к текущей версии, чтобы получить интересующую нас. Пример ниже прояснит ситуацию. В нашем распоряжении есть стабильная версия 2.6.16.25, и мы хотим перейти на версию разработки 2.6.20-rc1-git1. Распаковываем нашу копию исходников: $tar xjvf linux-2.6.16.25.tar.bz2 Качаем патч patch-2.6.16.25.bz2 и реверсируем.$ bzip2 -cd /pathjka/do/patch-2.6.16.25.bz2 | patch -p1 -R Теперь у нас есть версия 2.6.16 в нашем рабочем каталоге - это то, что мы имели в виду, стабильные и разрабатываемые патчи применяются исключительно к версии 2.6.x, так как они уже содержат патчи, включенные в 2.6.x.y. Теперь скачиваем патчи в версиях 2.6.17, 2.6.18 и 2.6.19 и применяем их по одному. $ bzip2 -cd /ścieżka/do/patch-2.6.17.bz2 | patch -p1 $ bzip2 -cd /path/do/patch-2.6.18.bz2 | patch -p1 $bzip2 -cd /path/do/patch-2.6.19.bz2 | patch -p1 Получили версию системы 2.6.19. Затем нужно скачать два патча разработки 2.6.20-rc1 и 2.6.20-rc1-git1, применяем их в заданном порядке. Разве это не так просто? Но утомительно - вот почему люди, которые не любят тратить время впустую, используют инструмент под названием кетчуп http://www.selenic.com/ketchup/. Подробнее о применении и скачивании патчей можно прочитать в файлах Documentation/apply-patches.txt и README из исходников ядра. Если при применении патча мы видим сообщение «patch: **** malformed patch at line», т.е.$ кошка ../sched-2.patch | patch -p1 -R --dry-run прошивочный файл kernel/sched.c patch: **** искаженный патч в строке 33: if (next == rq-> idle) это означает, что патч, скорее всего, был переформатирован наш почтовый клиент — или мы скопировали патч прямо со страницы архива LKML — тогда чаще всего исчезают все используемые в исходниках отступы. По http:
1.3. KETCHUP
5
//marc.theaimsgroup.com/?l=linux-kernel все сообщения доступны в текстовом виде (без форматирования HTML) - достаточно нажать на ссылку "Скачать сообщение RAW".
1.3
Ketchup
Ketchup — это инструмент, позволяющий быстро и легко загрузить последнюю версию интересующего вас ядра системы. Делает это довольно грамотно, проверяет текущую версию и скачивает только нужные патчи. Если мы используем тестовый/нестабильный Debian, то мы просто устанавливаем пакет кетчупа с помощью нашего любимого инструмента, например, # apt-get install ketchup available, тогда проще всего сделать: $ mkdir ~ / bin (если у нас нет bin в домашнем каталоге ) $cd~/bin$wget http://www.selenic.com/ketchup/ketchup-0.9.8.tar.bz2 $ tar xjvf ketchup-0.9.8.tar.bz2 У нас также должен быть установлен пакет python. Помните, что кетчуп может проверять подписи патчей, поэтому посетите http://www.kernel.org/signature.html и сохраните текущий ключ в текстовом файле ($ gpg --keyserver wwwkeys.pgp.net --recv -keys 0x517D0F0E у меня как-то никогда не получалось) и делаем: $gpg --import file_z_kluczem_kernel.org Теперь можем проверить как все это работает: $mkdir ~/tree $cd ~/tree $ketchup -m Вы должны получить такую ошибку: последний звонок последний): Файл "/usr/bin/ketchup", строка 695, в? lprint (get_ver ("Makefile")) Файл "/usr/bin/ketchup", строка 160, в get_ver m = open (makefile) IOError: [Errno 2] Нет такого файла или каталога: 'Makefile' Это означает, что только мы в этом каталоге нет деревьев Linux.Используйте команду "ketchup 2.6-tip" для загрузки последней версии "стабильного" дерева: Скачиваем patch-2.6.16.1.bz2 --21:11:47 - http://www.kernel.org/pub/linux/kernel/v2.6/patch-2.6.16.1.bz2 => '/home/michal /.ketchup/patch -2.6.16.1.bz2.partial '
6
ГЛАВА 1. ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ
Перевод www.kernel.org ... 204.152.191.5 www, 204.152.191.37 Подключение к .ядро.org | 204.152.191.5 |: 80 ... подключено. HTTP-запрос отправлен, ожидание ответа... 200 OK Длина: 5.284 (5.2K) [application/x-bzip2] 100% [===================== ==============>] 5,284
6,19К/с
21:11:49 (6,18 КБ/с) - '/home/michal/.ketchup/patch-2.6 .16.1.bz2.partial 'сохранено [5284/5284] Качаем patch-2.6.16.1.bz2.sign --21:11:49 - http://www.kernel.org/pub/linux/kernel/v2.6 / patch-2.6.16.1.bz2.sign => '/home/michal/.ketchup/patch-2.6.16.1.bz2.sign.partial' Перевод www.kernel.org ... 204.152.191.37, 204.152.191.5 Подключение к www.kernel.org | 204.152.191.37 |: 80 ... подключено. HTTP-запрос отправлен, ожидание ответа... 200 OK Длина: 250 [application/pgp-signature] 100% [========================= ===========>] 250
--.-- К/с
21:11:49 (18,34 МБ/с) - '/home/michal/.ketchup/ patch-2.6 .16.1.bz2.sign.partial 'сохранено [250/250] Проверка подписи... gpg: Подпись сделана вторник, 28 марта 2006 г., 09:37:31 CEST с использованием идентификатора ключа DSA 517D0F0E gpg: Хорошая подпись из "Проверки архивов ядра Linux" Ключ "gpg: ВНИМАНИЕ: Этот ключ не сертифицирован доверенной подписью! gpg: Нет уверенности в личности подписавшего.Печать главного ключа: C75D C40A 11D7 AF88 9981 ED5B C86B A06A 517D 0F0E Применение patch-2.6.16.1.bz2 Теперь мы вводим команду «ketchup -m», чтобы проверить, действительно ли у нас установлена последняя стабильная версия: $ ketchup -m 2.6.16.1 As как видите, ketchup при необходимости скачивает нужные патчи, а другие берет из папки ~/.ketchup в нашем домашнем каталоге — так что может быть хорошей идеей выкладывать уже имеющиеся у нас патчи туда. Переход на конкретную версию дерева для кетчупа не проблема.Просто введите «ketchup tree_version», например $ ketchup 2.6.16-rc4-mm1 2.6.16.1 -> 2.6.16-rc4-mm1 Применение patch-2.6.16.1.bz2 -R Применение patch-2.6.16.bz2 -R
1.4. ДЕРЕВЬЯ
7
Применение patch-2.6.16-rc4.bz2 Применение 2.6.16-rc4-mm1.bz2 или если вы хотите новейшее дерево -rt $ ketchup 2.6-rt ketchup 2.6-rt 2.6.16-rc4- mm1 -> 2.6.16-rt12 Применение 2.6.16-rc4-mm1.bz2 -R Применение patch-2.6.16-rc4.bz2 -R Применение patch-2.6.16.bz2 Применение patch-2.6.16-rt12 Инструмент автоматически применяет/кидает патчи.Чтобы получить архив патчей для последнего -mm, мы должны запустить $ wget -c 'ketchup -u 2.6-mm | sed "s / .bz2 / -broken-out.tar.bz2 /" 'Выбранные деревья: • 2.6-tip — текущая стабильная версия Linux • 2.6-rc — последняя версия разработки —rc • 2.6-git — последняя версия разработки —git • 2.6-rt — дерево Инго Молнара • 2.6-mm — дерево Эндрю Мортона • 2.6-ck — дерево Кона Коливаса (рабочий стол) • 2.6-cks — дерево Кона Коливаса (сервер) Почему я перечислил все эти команды стека? / обратные патчи ? Причина очень проста — если мы найдем и сообщим об ошибке, мы получим исправление для тестирования, которое мы должны уметь правильно применить.
1.4
Деревья
Мы часто сталкиваемся с термином "дерево ядра". Что это? Дерево — это набор патчей с собственным именем, например, дерево -mm, -rt, которые можно применять к определенной версии системы. Наиболее популярные деревья включают: • Дерево -mm (во главе с Эндрю Мортоном) представляет собой набор других меньших деревьев и экспериментальных патчей. • Дерево -rt (поддерживается Инго Молнаром) — содержит исправления для превращения Linux в систему реального времени.• Дерево -ck (во главе с Коном Коливасом) — фокусируется на повышении производительности системы.
8
ГЛАВА 1. ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ
Практически каждая подсистема разработчика и ядра имеет собственное дерево, над которым ведется работа. Через некоторое время различные части деревьев попадают в «сырое» дерево во главе с Линусом Торвальдсом.
1.5
-mm дерево
Как я упоминал ранее, -mm дерево "представляет собой набор других меньших деревьев и экспериментальных исправлений", именно здесь проходит основная линия борьбы с ошибками Linux.Схема потока патчей поможет вам понять значение этого дерева, и оно выглядит следующим образом (по крайней мере, так оно выглядит в теории): дерево -mm - деревья подсистем - дерево Линуса. Новые патчи, публикуемые разработчиками, либо идут сразу в дерево подсистем, либо сначала идут в -mm (если они идут сразу в дерево подсистем, то они все равно будут тестироваться в -mm, потому что из этих деревьев оно состоит). Эндрю Мортон объединяет все деревья в единое целое, которое затем выпускает для тестирования.Дерево -mm всегда доступно в виде отдельного патча и набора всего, из чего оно было собрано (вместе с исправлениями Эндрю). Это упрощает поиск исправлений ошибок (дополнительную информацию о quilt и бинарном поиске см. в главе 4). В каталоге, где лежат патчи (на kernel.org) вы найдете подкаталог hot-fixes — перед началом компиляции всегда стоит проверить его и скачать патчи, которые там есть. Патчи, включенные и выброшенные из дерева -mm, отправляются в список mm-commits (http://vger.kernel.org/vger-lists.html#mm-commits) — его отслеживание позволит нам узнать о его текущем содержании и упростит поиск патчей, вносящих новые ошибки. Время от времени Андрей присылает в mm-commits письмо с заголовком "mm snapshot breakout-date-time.tar.gz загружен". Это последний снимок дерева -mm, в основном для людей, которые хотят помочь "поставить его Вернуться вместе".
1.6
Компиляция, подготовка тестовой системы
Начать стоит с подготовки среды к работе, нам потребуются: gcc, make, binutils, util-linux, заголовочный пакет ncurses (libncurses5-dev в Debian или ncurses-devel в Федоре).В файле Documentation/Changes в исходном каталоге системы перечислены все программы, которые не обязательно требуются. Выполните следующие команды с правами администратора. # groupadd kernel # mkdir/usr/src/kernel #chgrp kernel/usr/src/kernel #chmod 775/usr/src/kernel/#usermod -G ядро
1.6. КОМПИЛЯЦИЯ, ПОДГОТОВКА ТЕСТ-СИСТЕМЫ
9
Первая команда создает новую группу под названием «ядро», затем создает рабочий каталог, изменяет права доступа к каталогу, чтобы пользователи, принадлежащие к группе «ядро», имели доступ на запись к Это.Последняя команда добавляет нашу учетную запись во вновь созданную группу. Если мы используем систему на базе Debian, то команда «usermod -G src» добавит нашу учетную запись в группу src, у которой уже есть права на запись в /usr/src. Учтите, что наш каталог /usr/src/kernel через некоторое время может занять несколько гигабайт, так что, возможно, нам стоит поместить его куда-нибудь еще. Чтобы скомпилировать ядро, нам нужно выполнить последовательность команд: • make oldconfig — обрабатывает наш старый конфигурационный файл (просто названный.config (в начале стоит точка - файл скрытый)) и спрашивает, хотим ли мы использовать новые опции, драйвера и т.д. • make menuconfig — позволяет изменить конфигурацию — пошаговые инструкции по настройке ядра можно найти по адресу: http://compile_jadra_linuxa_26.xt.pl/ • make — скомпилировать ядро системы • make modules_install — установить выбранные модули в /lib/modules/version • cp arch/i386/boot/bzImage /boot/vmlinuz-2.6.x.y — скопировать ядро в каталог /boot • cp System.map /boot/System.map-2.6.x.y — скопировать карту символов в каталог /boot В начале, когда мы еще не знаем, что включать и отключать в нашем файле конфигурации ядра, мы можем использовать конфигурацию ядра дистрибутива ( обычно там много лишнего, так что надо научиться настраивать ядро ;)). $ zcat /proc/config.gz> .config $ make oldconfig Некоторые полезные опции: • make O = /directory/ — сохраняет результат компиляции в другой каталог. Эта опция очень полезна, особенно если вы не хотите загромождать каталог ядра файлами *.п. (Вы также должны использовать модифицированные версии «make O = / menuconfig directory», «make O = / oldconfig directory», «make O = / modules_install directory» и т. д.). • make CC = — мы можем указать имя нашего компилятора gcc, например, в debian у нас есть несколько версий gcc, когда мы хотим скомпилировать ядро с версией 3.4, просто введите «make CC = gcc-3.4». • make C = 1 - исходники проверяются sparse перед компиляцией. • make -j — мы можем указать, сколько процессов gcc мы хотим запустить одновременно. На машинах SMP это ускоряет процесс компиляции.
10
ГЛАВА 1. ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ • make xconfig - конфигурация в графическом режиме (qt). • make gconfig - настройка в графическом режиме (gtk).
После выбора опции: Поддержка загружаемых модулей ---> [*] Включить поддержку загружаемых модулей [*] Автоматическая загрузка модулей ядра мы сможем использовать так называемые модули. Это фрагменты кода, которые не встроены в ядро постоянно. Благодаря модуляризации ядро можно сделать намного меньше, и поэтому оно может работать быстрее.Чтобы скомпилировать выделенный фрагмент кода в виде модуля, мы должны пометить его буквой «М» при настройке, например Проверить наличие нефатальных ошибок на AMD Athlon/Duron/Intel Pentium 4. если мы хотим смонтировать cd-rom, будет загружен модуль isofs.ko. Вы можете использовать команду modprobe (или insmod, rmmod) для ручной загрузки и выгрузки модулей • modprobe isofs — загрузит модуль isofs.ko • modprobe -r isofs — удалит модуль isofs.ko Все модули, доступные на данный момент для нашей системы, можно найти в подкаталоге ядра /lib/modules//. При настройке ядра стоит обратить внимание на опции в меню взлома ядра.Надо как минимум включить: [*]Отладка ядра [*]Скомпилировать ядро с отладочной информацией.Может значительно снизить скорость работы системы)[ *] [*] [*] [*] [*] [*] [*] [*] [*] [*] [*]
Отладка общих обработчиков IRQ Обнаружение программных зависаний Отладка распределения памяти slab Отладка утечки памяти RT Отладка мьютексов, обнаружение взаимоблокировок Встроенный тестер для rt-мьютексов с поддержкой сценариев Отладка блокировок: подтверждение правильности блокировок Отладка механизма зависимостей блокировок Самотестирование API блокировок во время загрузки Отладка Highmem Debug VM
1.6. КОМПИЛЯЦИЯ, ТЕСТИРОВАНИЕ ПОДГОТОВКА СИСТЕМЫ
11
Очень полезной функцией является ключ [*] Magic SysRq, который часто позволяет ограничить последствия ошибки ядра и может использоваться для получения дополнительной информации о состоянии системы. Он предлагает сочетания клавиш, которые позволяют нам выполнять строго определенные инструкции: • Alt + SysRq + h — отображает справку • Alt + SysRq + b — немедленная перезагрузка системы, без размонтирования дисков и сохранения буферов. ОПАСНЫЙ! • Alt + SysRq + c — аварийный дамп • Alt + SysRq + e — отправляет сигнал TERM всем процессам, кроме процесса INIT • Alt + SysRq + i — отправляет сигнал KILL всем процессам, кроме процесса INIT • Alt + SysRq + k - последовательность SAK (Ключ безопасного доступа), убивающая все процессы на данной консоли, т.е.Экстренное завершение работы XWindow при сбое Ctrl + Alt + Backspace • Alt + SysRq + l — отправляет сигнал KILL всем процессам, включая процесс INIT, что приводит к остановке системы • Alt + SysRq + m — информация о памяти • Alt + SysRq + o — завершение работы системы • Alt+SysRq+p — отображает содержимое регистров и флаги процессора • Alt+SysRq+r — переключает клавиатуру в режим RAW — когда, например, не работает Ctr+Alt+Del • Alt+SysRq+s — синхронизация дисков и сохранение содержимого дисковых буферов • Alt + SysRq + t — список всех задач • Alt + SysRq + u — перемонтировать все файловые системы в режиме SysRq только для чтения, какой это ключ? • x86 — Print Screen • SPARC — STOP • последовательная консоль — Break • PowerPC — PrintScreen (или F13)
12
ГЛАВА 1.ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ • Все - echo t>/proc/sysrq-trigger
Как безопасно перезагрузить компьютер? Во-первых, мы должны попробовать Ctrl + Alt + Backspace (XWindow) или Ctrl + Alt + Del (консоль). Если это не удается: • завершить все процессы на данной консоли: Alt + SysRq + k • безопасно перезагрузить компьютер: Alt + SysRq + s Alt + SysRq + u Alt + SysRq + b Дополнительная информация о «Волшебном ключе SysRq» может можно найти в документации/sysrq.txt. В некоторых дистрибутивах (или если мы скомпилировали драйверы нашего контроллера SCSI/IDE/SATA или файловой системы, используемой на/в качестве модуля) нам необходимо сгенерировать так называемыйinitrd. Это должно помочь вам, запустив $ make install Если вы используете grub, ваш файл конфигурации /boot/grub/menu.lst. Введите его: title Linux 2.6.root version (hd0,0) kernel /boot/vmlinuz-2.6.ro root version = /dev/ # Если используем initrd # initrd /boot/initrd-2.6.version.img /etc/lilo .conf введите image=/boot/vmlinuz-2.6.version label=linux initrd=/boot/initrd-2.6.version.img read-only root=/dev/ Затем нужно уведомить lilo об изменении конфигурации $sudo /sbin/lilo Описанные выше шаги уже можно выполнить с помощью скрипта установки ядра, доступного в нашем дистрибутиве.Дополнительную информацию о настройке загрузчиков можно найти в "man lilo.conf" и "info grub". Ниже приведен скрипт, с помощью которого вы можете скачать, скомпилировать и установить последнее стабильное ядро. Скрипт достаточно универсальный, а также его легко адаптировать под свои нужды. #! /bin/sh # Путь к каталогу исходников ядра SRC_PATH="/usr/src/kernel/linux-stable" OBJ_PATH="$SRC_PATH-obj/"
1.6. СБОРКА, ПОДГОТОВКА ПРОВЕРКИ СИСТЕМЫ
13
cd $SRC_PATH# Загрузите последнюю версию кетчупа 2.6 # Запомнить версию VER = 'ketchup -m' # Обновить конфигурацию make O = $OBJ_PATH oldconfig # Собрать ядро make O = $OBJ_PATH # Установить модули sudo make O = $OBJ_PATH modules_install # Скопировать сжатый образ ядра в /boot sudo cp $OBJ_PATH /arch/i386/boot/bzImage/boot/vmlinuz-$VER # Скопируйте System.map в /boot sudo cp $OBJ_PATH/System.map/boot/System.map-$VER # Если вы используете Fedora, вам необходимо сгенерировать fedora initrd # sudo/sbin/new-kernel-pkg --make-default --mkinitrd --depmod \\ --install $VER Ниже приведены ссылки на инструкции по сборке ядра с использованием конкретных дистрибутивов CentOS http://www.Howtoforge.com/kernel_compilation_centos (англ.) Debian http://www.debian.org/doc/manuals/reference/ch-kernel.pl.html http://www.howtoforge.com/howto_linux_kernel_2.6_compile_debian (англ.) Fedora http://www.howtoforge.com/kernel_compilation_fedora Gentoo http://www.gentoo.org/doc/pl/kernel-upgrade.xml Mandriva http://www.howtoforge.com/kernel_compilation_mandriva .) OpenSUSE http:/ /www.howtoforge.com/kernel_compilation_suse (англ.) Ubuntu http://www.howtoforge.com/kernel_compilation_ubuntu (англ.)) Дополнительную информацию о секретах настройки и компиляции ядра см. в книге Грега Кроа-Хартмана «Ядро Linux в двух словах» http://www.kroah.com/lkn/ Linux имеет очень специфическую модель разработки, не встречающуюся в других открытых или закрытые проекты, поэтому стоит прочитать правила, регулирующие это http: // www. stardust.webpages.pl/ltg/wiki/index.php/Proces_rozkieta_j%C4%85dra_Linux Краткие советы: • введите «make help» и посмотрите варианты • в меню «Kernel hacking
--->» вы можете найти множество полезных опций
• просмотреть опции сценария кетчупа
14
ГЛАВА 1.ЯДРО, ПАТЧИ, ДЕРЕВЬЯ И КОМПИЛЯЦИЯ
Глава 2 Тестирование Процесс тестирования можно разделить на три этапа: 1. Использование пробной версии для нормальной работы. 2. Использование программ тестирования системы, например, LTP. 3. Выполнение нестандартной деятельности.
2.1
"Фаза 1"
Первая фаза проста - пробуем запустить систему: • вначале в минимальной конфигурации с параметром init=/bin/bash и в автономном режиме (передаем 1 или 2 к параметрам ядра - зависит от дистрибутива (проверьте в документации дистрибутива или в файле /etc/inittab, какой уровень инициализации запускает систему без поддержки сети) (grub полезен как загрузчик)) • только после проверки минимальной конфигурации , запускаем систему нормально Затем скачиваем файл из сети, получаем почту, записываем диск с данными/аудио (пригодится CD, DVD-RW) и т.д.
2.2
«Фаза 2 (Автотест)»
На следующем этапе мы используем специализированные программы для проверки корректной работы различных подсистем ядра, а также проводим регрессионные тесты и тесты производительности. Последние очень ценны для разработчиков (и для нас) — если переход с 2.6.x-rc1 на 2.6.x-rc2 привел к падению производительности файловой системы на 10%, то стоит отследить, какой именно патч вызвал это. Для автоматизированного тестирования рекомендую использовать платформу AutoTest http://test.kernel.org/автотест/. Он состоит из различных типов тестов и инструментов для профилирования системы, инкапсулированных в простой в использовании API. Сначала нам следует зайти в каталог /usr/local, рекомендованный в документации, и как привилегированный пользователь 15
16
ГЛАВА 2. ТЕСТИРОВАНИЕ
выполнить команду "svn checkout svn://test.kernel.org/autotest /автотест багажника". При работе с AutoTest мы будем использовать учетную запись привилегированного пользователя, вопреки всем рекомендациям не работать с такой учетной записью.Причина очень проста, большая часть тестов требует прав администратора, а AutoTest должен быть неинтерактивной платформой. Благодаря этому мы можем оставить его без присмотра на несколько часов и не переживать, если всплывет запрос на ввод пароля администратора. (Это тоже еще один хороший аргумент в пользу использования отдельных тестовых систем — если что-то пойдет не так, мы уничтожаем только систему, предназначенную для тестирования, а не для работы :) Самый простой способ запустить тест — запустить команду «bin/autotesttests/ test_name/control" после перехода к клиенту.AutoTest читает управляющий файл и выполняет содержащиеся в нем инструкции. Простейшая форма управляющего файла: job.run_test('ltp'). Он не указывает никаких параметров для передачи тесту, он содержит только его имя. Более «сложные» контрольные файлы имеют вид: job.run_test('punktgen', 'eth0', 50000, 0, tag='clone_skb_off') job.run_test('punktgen', 'eth0', 50000, 1, tag= ' clone_skb_on ') Они передают параметры тестовым программам. Мы можем изменить эти параметры после прочтения тестовой документации и файла test/имя_теста/имя_теста.ру. Когда AT выясняет, какой тест запустить и какие параметры ему передать, он запускает файлtests/имя_теста/имя_теста.py. Чаще всего он немного длиннее представленного ниже, но этот хорошо показывает, что должно быть в таком файле. import test, os_dep from autotest_utils import * class isic (test.test): version = 1 # http://www.packetfactory.net/Projects/ISIC/isic-0.06.tgz # + http://www.stardust.webpages .pl/files/crap/isic-gcc41-fix.patch def setup (self, tarball = 'isic-0.06.tar.bz2 '): tarball = unmap_url (self.bindir, tarball, self.tmpdir) extract_tarball_to_dir (tarball, self.srcdir) os.chdir (self.srcdir) os_dep.library ('libnet.so') system( './configure') system ('make') def execute (self, args = '-s rand -d 127.0.0.1 -p 10000000'): system (self.srcdir + '/ isic' + args)
Первый функция, содержащаяся в скрипте, является функцией setup(), которая предназначена для подготовки теста к запуску, т.е. она выполняет настройку и компиляцию теста за нас. Как следует из названия, функция execute() запускает тест с заданными параметрами.Результаты теста можно посмотреть в каталоге results/default/название_теста/. Файл состояния сообщает вам, был ли тест успешным или нет. Если вы хотите запустить несколько тестов друг за другом, лучше всего подготовить файл с инструкциями для самопроверки. Он должен содержать ту же информацию, что и в управляющих файлах. Например, первые пять строк «samples/all_tests» выглядят так: job.run_test('aiostress') job.run_test('bonnie')
2.3. «ФАЗА 3»
17
job.run_test («dbench») job.run_test («fio») job.run_test («fsx») Затем мы запускаем самопроверку и вводим наш файл управляющей информации как параметр. Мы также можем просто запустить команду «bin/autotest Samples/all_tests», но мы должны быть готовы к тому, что выполнение всех содержащихся в ней тестов займет очень много времени. Если мы хотим запустить несколько тестов параллельно, контрольный файл должен иметь тот же синтаксис, что и файл примера «samples/parallel» def kernbench():job.run_test('kernbench', 2, 5) def dbench(): job.run_test('dbench') job.parallel([kernbench], [dbench]) (Мы можем остановить тест в любой момент, используя Ctrl + c) Для людям, которым не нравится командная строка и конфигурационные файлы, был создан ATCC (Центр управления автотестами). Его можно запустить командой «ui/menu». В нашем распоряжении система простых меню, в которых мы можем выбирать тесты, профилирующие программы, просматривать результаты их выполнения и выполнять простую настройку.Если вам наскучил набор инструментов AutoTest, вы всегда можете посетить http://ltp.sourceforge.net/tooltable.php. Он имеет большой список инструментов, которые можно использовать для тестирования системы.
2.3
"Фаза 3"
Итак, первые два этапа тестирования система прошла без проблем? Мы можем начать импровизировать, т.е. делать глупости, которые никто не делает, чтобы они не знали, что могут вызвать упс :). Но что делать? Если бы существовал какой-то стандартный способ, он определенно оказался бы в каком-то наборе тестов.На третьем этапе мы можем начать с удаления и замены штекеров устройств, подключенных к шине USB. Пока перевод затычек по идее ничего менять не должен, пресловутое выдергивание и вставление затыка может вызвать упс из леса (при условии, что кто-то еще не пробовал до этого с похожей конфигурацией ПК). Затем мы можем написать скрипт, который будет перебирать содержимое файлов в каталоге /proc. В двух словах, третья фаза делает то, что обычные пользователи не делают (или делают очень редко — зачем кому-то бесконечно монтировать и размонтировать файловую систему? :).
18
2.4
ГЛАВА 2. ТЕСТИРОВАНИЕ
Измерение производительности
Как я упоминал ранее, стоит проверить влияние внесенных в систему изменений на ее производительность (кстати, это может быть отличным занятием для начинающие тестировщики, которые еще не хотят тестировать больше разрабатываемых версий системы, и хотят очень помочь в ее разработке). Но с чего начать и что стоит знать? В начале стоит решить протестировать конкретную подсистему — давайте выберем ту, которую будем тестировать регулярно — тогда наши данные будут гораздо ценнее для разработчиков.Иногда кто-то отправляет в LKML письмо типа: «Здравствуйте, я заметил сильное снижение производительности на моей сетевой карте после обновления ядра с 2.6.8 до 2.6.20. Кто-нибудь знает, что с этим делать?» Конечно, никто не может иметь ни малейшего представления о том, что произошло, потому что между релизом ядра 2.6.8 и 2.6.20 прошло более двух с половиной лет (и куча разных рандомных патчей). Если мы напишем, что между версиями 2.6.x-rc3 и 2.6.x-rc4 производительность нашей видеокарты снизилась на 50%, то несложно будет выяснить, почему это произошло.Поэтому важно регулярно проводить измерения. Второе, что требует внимания, это детали отдельных тестов — нам нужно узнать как можно больше о данном бенчмарке. Главное, чтобы полученные результаты были достоверными. Иногда в различных публикациях в прессе/интернете мы можем встретить тест производительности под названием «time make». Речь идет о проверке скорости сборки ядра с помощью времени программы. Это тест, который следует классифицировать как ненадежный.Почему? Ответ на этот вопрос очень прост, если обратить внимание на то, что файлы загружаются с диска перед компиляцией. Скорость чтения отличается от диска к диску, а также зависит от того, где находятся данные и как они разбросаны. В то время как скорость процессора и оперативной памяти можно считать постоянной, скорость чтения данных с диска настолько случайна, что между отдельными результатами могут быть значительные различия. Для получения достоверных результатов необходимо как-то избежать несовершенства винчестеров - проще всего будет кэшировать данные в оперативной памяти (Linux очень интенсивно кэширует данные, считанные с дисков, что ускоряет их последующее повторное чтение) .Если мы хотим провести испытания под названием «Время делать» и получать достоверные результаты, лучше всего использовать скрипт kernbench http://ck.kolivas.org/kernbench/ или более новую версию платформы AutoTest. Еще одна вещь, о которой стоит помнить, это стабильность (неизменность) среды, в которой мы проводим измерения, то есть мы не должны обновлять программы, которые могут повлиять на полученные данные. Если наши измерения основаны на компиляции ядра, пусть это будет все время одна и та же версия исходников и один и тот же конфигурационный файл (компилятор и все инструменты, необходимые для сборки ядра, тоже не должны менять свою версию).Хорошим примером плохого тестирования может быть сравнение производительности файловой системы, когда фактор сборки жесткого диска не принимался во внимание. Как упоминалось ранее, скорость чтения/записи варьируется от места к месту на диске, поэтому нам не следует создавать пять разделов для тестирования пяти разных файловых систем. Единственный способ получить достоверные результаты — создать один раздел (а не перемещать его), на котором мы будем создавать разные файловые системы.Между последующими
2.5. ДОБРО ПОЖАЛОВАТЬ В МИР, ЧТО МЫ ИЩЕМ?
19
измерений лучше всего перезапустить систему, а также обойти фактор буферизации данных. На http://ltp.sourceforge.net/tooltable.php вы можете найти несколько хороших тестов (некоторые из них также есть в AutoTest), но мы должны помнить, что нас волнует не производительность оборудования, а система. Поэтому рекомендую ознакомиться с документацией выбранного бенчмарка — в ней обычно содержится некоторая полезная информация.Подводя итог, самое важное в измерении производительности: • регулярные измерения • знание «деталей», позволяющих получать надежные результаты • стабильность тестовой среды Если все три фактора соблюдены, данные, которые мы предоставляем, будут бесценными. источник информации о производительности той или иной подсистемы.
2.5
Привет, мир, что именно мы ищем?
Что мы на самом деле ищем? Ниже приведены примеры ошибок, с которыми можно столкнуться при тестировании системы.============================================ [ИНФОРМАЦИЯ: возможный рекурсивный обнаружена блокировка] ----------------------------------------------------------- холостой / 1 пытается получить блокировку: (lock_ptr) {....}, at: [] acpi_os_acquire_lock + 0x8 / 0xa, но задача уже удерживает блокировку: (lock_ptr) {....}, at: [] acpi_os_acquire_lock + 0x8 / 0xa другая информация, которая может помочь нам отладить это: 1 блокировка удерживается в режиме ожидания / 1: # 0: (lock_ptr) {....}, at: [] acpi_os_acquire_lock + 0x8 / 0xa отслеживание стека: [] show_trace + 0xd / 0x10 [] dump_stack + 0x19 / 0x1b [] __lock_acquire + 0x7d9 / 0xa50 [] lock_acquire + 0x71 / 0x91 [] _spin_lock_irqsave + 0x2c / 0x3c [] acpi_os_acquire_lock + 0x8 / 0xa [] acpi_ev_gpe_dxevect + 0x1_dpi_101 [] acpi_ev_g4d15detvect + 0x1_dpi_101 [] ] acpi_irq + 0xe / 0x18 [] request_irq + 0xbe / 0x10c [] acpi_os_install_interrupt_handler + 0x59 / 0x87 [] acpi_ev_install_sci_handler + 0x1c / 0x21 [] acpi_ev_install_xhandlers + 0x9 / 0x21 [] ACPI_INSTALL_XHANDLERS + 0x9 / 0x51 [] ACPI_INSTALL_XHANDLER /subf 0x9a70] _stext + 0x116 / 0x26c [] kernel_thread_helper + 0x5 / 0xb
Выше ej обнаружена ошибка механизмом проверки использования блокировок в системе (lockdep).
20
ГЛАВА 2. ТЕСТИРОВАНИЕ
ОШИБКА: спящая функция вызывается из недопустимого контекста в /usr/src/linux-mm/sound/core/info.c:117 in_atomic(): 1, irqs_disabled(): 0 show_trace + 0xd / 0xf dump_stack + 0x17 / 0x19 __might_sleep + 0x93 / 0x9d snd_iprintf + 0x1b / 0x84 [snd] snd_card_module_info_read + 0x34 / 0x4e [snd] snd_info_entry_open + 0x20f / 0x2open + 0x20f / 0x2ccid3cp / 0x2ccid3cp / 0x2ccid3cp / 0x2ccid3cp / 0x2ccid3c / 0x2ccid1 / 0x2ccid1 / 0x602 0x2e / 0x35 do_sys_open + 0x54 / 0xd7 sys_open + 0x16 / 0x18 sysenter_past_esp + 0x54 / 0x75. 0x20d [] dimp_stack + 0x17 / 0x19 [] debug_smp_processor_id + 0x8c / 0xa0 [] __handle_mm_fault + 0x2b / 0x20d [] do_page_fault + 0x226 / 0x61f [] error_code + 0x39 / 0x40 [] PADZE ] 0x8elf36_binary_hand] + 0x123 / 0x35a [] load_script + 0x221 / 0x230 [] search_binary_handler + 0x123 / 0x35a [] do_execve + 0x164 / 0x215 [] sys_execve + 0x3b / 0x7e [ ] syscall_call+0x7/0xb
Ниже приведен так называемыйупс - после чего, очень часто наша система заканчивает т.н. паника ядра. Итак, случилось что-то действительно плохое, и наша система перестает работать, чтобы не рисковать потерей данных или другими неприятными событиями. (В статье OSWeekly.com Пуру Говинд объяснил, откуда взялась паника ядра и что такое http://www.Osweekly.com/index.php?option=com_content&task=view&id=2241&Itemid=449 (англ.)) BUG: невозможно для обработки запроса пейджинга ядра по виртуальному адресу 6b6b6c07 печать eip:c0138722*pde=00000000 Oops:0002[#1] 4K_STACKS PREEMPT SMP последний sysfs файл: /devices/pci0000:00/0000:00:1d.7/uevent Modules linked in: snd_timer snd soundcore snd_page_alloc intel_agp agpgart ide_cd cdrom ipv6 w83627hf hwmon_vid hwmon i2c_isa i2c_i801 skge af_packet ip_conntrack_netbios_ns ipt_REJECT xt_state ip_conntrack nfnetlink xt_tcpudp iptable_filter ip_tables x_tables cpufreq_userspace p4_clockmod speedstep_lib binfmt_misc thermal processor fan container rtc unix CPU: 0 EIP: 0060:[ ] Not tainted VLI EFLAGS: 00010046 (2.6.18-rc2-mm1 # 78) EIP is at __lock_acquire + 0x362 / 0xaea eax: 00000000 ebx: 6b6b6b6b ecx: c0360358 edx: 00000000 esi: 00000000 edid0: f54400 edbd0: f54400 edbd0: f50044 ds: 007b es: 007b ss: 0068 Процесс udevd (pid: 1353, ti = f544d000 задача = задача f6fce8f0.ti=f544d000) Stack: 00000000 00000000 00000000 c7749ea4 f6fce8f0 c0138e74 000001e8 00000000 00000000 f6653fa4 00000246 00000000 00000000 f544de1c c0139214 00000000 00000002 00000000 c014fe3a c7749ea4 c7749e90 f6fce8f0 f5b19b04 f544de34 Call Trace: [] lock_acquire+0x71/0x91 [] _spin_lock+0x23/0x32 [] __delayacct_blkio_ticks + 0x16 / 0x67 [] do_task_stat + 0x3df / 0x6c1 [] proc_tgid_stat + 0xd / 0xf [] proc_info_read + 0x50 / 0xb3
2.5. ДОБРО ПОЖАЛОВАТЬ В МИР, ЧТО МЫ ИЩЕМ?
21
[] vfs_read + 0xcb / 0x177 [] sys_read + 0x3b / 0x71 [] sysenter_past_esp + 0x56 / 0x8d DWARF2 unwinder stuck at sysenter_past_esp + 0x56 / 0x8d Leftover inexact backtrace 0x8_l show_stlack + 0x8_l show_stlack + showlog_l show_st97 0x15c / 0x1ed [ ] die + 0x1b2 / 0x2b7 [] do_page_fault + 0x410 / 0x4f0 [] error_code + 0x39 / 0x40 [] lock_acquire + 0x71 / 0x91 [] _spin_lock + 0x23 / 0x32 [] __delayacct_blkio_ticks [] __delayacct_blkio_ticks [+ 0x16t 0x67_stat] + 0x16t 0x67 / 0x6c1 [] proc_tgid_stat + 0xd / 0xf [] proc_info_read + 0x50 / 0xb3 [] vfs_read + 0xcb / 0x177 [] sys_read + 0x3b / 0x71 [] sysenter_past_esp + 0x56 / 0x8d Код: 68 4b 75 2f c0 3 b 07 0 0 68 07 0 c0 68 e3 06 31 c0 e8 ce 7e fe ff e8 87 c2 fc ff 83 c4 10 eb 08 85 db 0f 84 6b 07 00 00 ff 83 9c 00 00 00 8b 55 dc 8b 92 5c 05 00 00 89 3fa 55 eIP :[] __lock_acquire + 0x362/0xaea SS:ESP 0068:f544ddc0
Приведенный ниже тип ошибки чаще всего вызван ситуацией, когда разработчики говорят, что этого не должно происходить :).KERNEL: KERNEL: KERNEL: KERNEL:
утверждение утверждение утверждение утверждение
((int) tp->lost_out>=0) failed at net/ipv4/tcp_input.c(2148)((int)tp->lost_out>= 0) ошибка в сети /ipv4/tcp_input.c (2148) ((int) tp->sacked_out>=0) ошибка в сети /ipv4/tcp_input.c (2147) ((int)tp->sacked_out>=0) ошибка в net/ipv4/tcp_input.c (2147)
ОШИБКА: предупреждение в /usr/src/linux-mm/kernel/cpu.c:56/unlock_cpu_hotplug () [] dump_trace + 0x70 / 0x176 [] show_trace_log_lvl + 0x12 / 0x22 [] show_trace + 0xd / 0xf [] dump_stack + 0x17 / 0x19 [] unlock_cpu_hotplug + 0x46 / 0x7c [] cpufreq_set + 0x81 / 0x8b [cpufreq_userspace] [] store_speed + 0x35 / 0x40 [cpufreq_userspace] [] flush_write_buffer + 0x2buffer [] sysfs_write_file + 0x4b / 0x6c [] vfs_write + 0xcb / 0x173 [] sys_write + 0x3b / 0x71 [] sysenter_past_esp + 0x56 / 0x8d [] 0xb7fbe4drace_log] 0xb7fbe4d [] 0xb7fb7fbe4drace_log] 0xb7fbe4d [] 0xb7fbe4drace_log_past_esp. ] unlock_cpu_hotplug + 0x46/0x7c [] cpufreq_set + 0x81/0x8b [cpufreq_userspace] [] store_ скорость + 0x35 / 0x40 [cpufreq_userspace] [] store + 0x38 / 0x49 [] flush_write_buffer + 0x23 / 0x2b [] sysfs_write_file + 0x4b / 0x6c [] vfs_write + 0xcb / 0x173 [] sys_write + 0x3d + 0x71 [] 0x7d + 0x3d_write [] sys_write + 0x3b / 0x71 [] sys_write + 0x3b / 0x71 []
Здесь у нас есть результат сканирования /sys/kernel/debug/memleak (детектор утечек памяти ядра еще не является частью стандартного ядра) orphan pointer 0xf5a6fd60 (размер 39): c0173822:
22
ГЛАВА 2.ТЕСТИРОВАНИЕ
c01df500: c01df679: c01d7eee: f884f019: f8850698: c02a88c2: c02a9c7a:
С помощью этой информации и нашего файла конфигурации ядра разработчики могут исправить обнаруженную нами ошибку. Помимо перечисленных выше ошибок, мы можем столкнуться с ситуацией, когда ядро не будет собираться из-за ошибки времени компиляции. Это очень редкая проблема, которая свидетельствует о крайней небрежности автора кода. Хорошим примером может быть мое исправление для драйвера кадрового буфера SIS, который не компилировался как модуль... Иногда причиной ошибки является сбойная работа, например, нашего компилятора, неправильно собирающего ядро. Также программы, использующие некоторые части ABI (Application Binary Interface), могут перестать работать корректно после его изменения в новой версии — в таких случаях важно определить, было ли изменение ABI преднамеренным или случайным. Некоторые проблемы видны не всегда сразу, некоторые возникают только в определенных ситуациях и могут проявляться, например, приостановкой случайных процессов, забрасыванием или забрасыванием случайных данных в сохраненные файлы и т.д.Одним словом, нужно держать глаза и уши открытыми. Мы можем классифицировать ошибки несколькими различными способами, но наиболее полезная для нас классификация делит их на два типа: • легко воспроизводимые — те, о которых мы точно знаем, когда и где они происходят • трудно воспроизводимые — возникают (казалось бы) случайно и мы не знаю точно, как их воссоздать. Первый тип легче всего исправить, очень легко найти патч, который внес ошибку. Второй тип — это тип, который никому не нравится.Если у нас нет соответствующего опыта, нам придется полагаться на опыт разработчиков.
2.6
Бинарные драйверы и ядра дистрибутива
Мы часто слышим, что бинарные драйверы плохи и не должны использоваться, но почему? Причина проста — если мы найдем ошибку и отправим отчет в список рассылки ядра Linux, разработчики не смогут нам помочь, потому что у них нет доступа к коду драйвера с закрытым исходным кодом. Информацию об используемом драйвере можно получить из строки "EIP:0060:[]Tainted:P VLI", буква "P" сообщает нам, что использовался драйвер с закрытым кодом.Вы должны попытаться воспроизвести эту ошибку без загруженного двоичного двоичного объекта. Мы должны сообщить об ошибке разработчикам драйвера и позволить им заняться ее исправлением. В файле Documentation/oops-tracing.txt мы можем найти список причин, по которым данное ядро считалось «зараженным». Итого:
бинарных драйвера 2.6. БИНАРНЫЕ ДРАЙВЕРЫ И ДИСТРИБУЦИИ KINES
23
очень полезны - если вы заметили какие-либо ошибки, пожалуйста, отправьте их производителям, а не LKML. Иногда люди отправляют отчеты об ошибках, обнаруженных в ядрах дистрибутива, в LKML, этого делать не следует по нескольким причинам: • ядра дистрибутива содержат модификации, которых нет в стандартной версии • часто эти модификации содержат ошибки (иногда они очень экспериментальные) • ошибка скорее всего не возникает в исходной версии • нехорошо обвинять людей в ошибках, которые они скорее всего не совершали :) Надо попытаться воспроизвести такую ошибку на ядре ядра.org, если это не удается, это ошибка производителя дистрибутива, и ему следует сообщить об этом.
24
ГЛАВА 2. ТЕСТИРОВАНИЕ
Глава 3 Обнаружение ошибок Существует несколько методов обнаружения ошибок — один более эффективный, другой менее эффективный — каждый со своими преимуществами и недостатками. Самый распространенный метод — использование sysklogd, демона, который записывает информацию, которую печатает ядро, в лог-файл (этот файл может быть /var/log/messages или /var/log/kern.log — зависит от конфигурации sysklogd в нашем дистрибутиве). Преимущество этого метода в том, что практически в каждом дистрибутиве sysklogd доступен по умолчанию и его не нужно настраивать. К недостаткам можно отнести то, что он очень поздно запускается в процессе загрузки (и очень раннее завершение работы при выключении), что очень часто не дает возможности отловить ошибку, возникающую на ранней фазе запуска системы или поздней фазе ее остановки. В методе, который мы можем назвать «традиционным», мы используем лист бумаги и что-то, на чем можно писать... Это очень трудоемко и никому не нравится, потому что можно сделать много ошибок, переписывая все буквы и цифры. Иногда текст ошибки вылетает с экрана и мы мало что можем с этим поделать, кроме запуска системы с параметром "vga=1", благодаря чему у нас будет консоль с разрешением 80 столбцов на 50 строк. К сожалению, при "более интересных" ошибках 50 строк может не хватить. Вместо того, чтобы переписывать содержание ошибки, мы можем просто ее сфотографировать и разместить такой «скриншот» у себя на сайте (стоит уменьшить разрешение, например, до1024x768 и изменить цветовую шкалу на оттенки серого, фото будет немного меньше). Мы не должны отправлять фотографии в LKML во вложениях, потому что они обычно слишком велики (LKML имеет ограниченный размер письма до 100 КБ).
3.1
Последовательная консоль
Метод отлова ошибок с помощью последовательной консоли имеет один существенный недостаток - для этого требуется два компьютера. Мы соединяем их с помощью последовательного кабеля, подключенного к одному из COM-портов (обычно COM1). Во-первых, нам нужно настроить последовательную консоль в ядре драйверов устройств ---> Символьные устройства ---> Последовательные драйверы ---> 8250/16550 и поддержка совместимых последовательных портов 25
26 [*]
ГЛАВА 3.СБРОС ОШИБКИ Консоль на 8250/16550 и совместимый последовательный порт
Затем добавьте в /boot/grub/menu.lst серийный номер --unit = 0 --speed = 115200 --word = 8 --parity = no --stop = 1 terminal --timeout=5 serial console and console=ttyS0,115200n8 console=tty0 к параметрам, с которыми запускаем ядро. Приведенные ниже рекомендации относятся к дистрибутивам Fedora, в других дистрибутивах вам может не понадобиться выполнять описанные ниже шаги. Отредактируйте файл /etc/sysconfig/init и установите для переменной BOOTUP значение «serial».Затем в файле /etc/sysconfig/kudzu включаем режим "SAFE=yes" и в файле /etc/securetty добавляем "ttyS0". Теперь в файле /etc/inittab добавляем строчку S1:23:respawn:/sbin/mgetty -L ttyS0 115200 vt100 (у нас должен быть установлен пакет mgetty). Описанные выше шаги следует выполнить на обоих компьютерах — последовательная консоль всегда может пригодиться. Если нам это не нужно, нам просто нужно сделать комментарий перед параметрами, разрешающими это. На компьютере, который будет использоваться для захвата данных, запустите программу журнала # minicom -o -C.txt Вероятно, вы получите ошибку «Device /dev/modem/access failed: (..)», для ее исправления просто создайте символическую ссылку на ttyS0 # ln -s /dev/ttyS0/dev/modem Не забудьте установить соответствующий параметры передачи! Дополнительную информацию о настройке последовательной консоли можно найти в Документация/serial-console.txt
3.2
Веб-консоль
Самый большой недостаток этого метода обнаружения ошибок (как и в случае с последовательной консолью) заключается в том, что он требует использования из двух компьютеров.С другой стороны, несомненный плюс в том, что компьютеры могут находиться далеко друг от друга — мы не ограничены длиной последовательного кабеля. Немного меньшим недостатком веб-консоли является то, что она начинает работать только тогда, когда сеть запущена и работает, поэтому она не подходит для обнаружения всех ошибок. (К сожалению, сетевая консоль работает только на картах Ethernet.) Начинаем настройку, выбрав один вариант при настройке ядра Драйверы устройств --->Поддержка сетевых устройств --->Поддержка ведения журнала сетевой консоли (ЭКСПЕРИМЕНТАЛЬНО) Затем добавляем строчку аналогичную на следующий [email protected]/eth0, [email protected]/00:14:38:C3:3F:C4
3.2. СЕТЕВАЯ КОНСОЛЬ
27
Первые три параметра относятся к компьютеру, с которого мы будем захватывать данные: • 4444 — порт, на который будут отправляться данные • 192.168.100.1 — IP-адрес интерфейса • eth0 — интерфейс через который мы будем отправлять данные Следующие три параметра относятся к компьютеру, на котором мы будем ловить ошибку: • 6666 — порт, на котором мы будем прослушивать • 192.168.100.2 — IP-адрес интерфейса, который будет получать данные • 00:14:38:C3:3F:C4 - MAC-адрес карты, которая будет принимать данныеnetcat http://netcat.sourceforge.net/ # netcat -u -l -p 6666 Полезную информацию о веб-консоли можно найти в Documentation/networking/netconsole.txt Советы: • прочтите команду dmesg • найдите файл в какой ваш любимый дистрибутив хранит журналы ядра
28
ГЛАВА 3. ПОЛУЧЕНИЕ ОШИБОК
Глава 4 Git, quilt и бинарный поиск Разработчики используют два основных инструмента git и quilt для управления деревьями.Вы также можете использовать несколько оверлеев (Cogito, Stacked GIT, Patchy Git (pg), (h) gct), но я сосредоточусь на описании первых двух инструментов, потому что они принципиально различаются по способу работы и подходу к управлению деревом. .
4.1
Git
Git — это система контроля версий, написанная Линусом Торвальдсом для ядра Linux (текущий мейнтейнер git — Джунио К. Хамано). Установка так же проста, как установка пакета git-core из нашего любимого дистрибутива или загрузка http://www.kernel.org/pub/software/scm/git/ и самостоятельная компиляция. (Прежде чем приступить к клонированию дерева, хорошенько подумайте — оно вам понадобится? Если вы не планируете проводить обширное тестирование, почему бы не использовать обычные патчи? В настоящее время дерево linux-2.6 занимает чуть более 600 МБ из-за клонирование kernel.org при большой нагрузке займет много времени...) Нашим первым шагом после установки git должно быть клонирование репозитория, например.тот, которым управляет Линус $ git-clone git: //git.kernel.org/pub/scm/linux/kernel/git/torvalds/ linux-2.6.git linux-git Клонирование репозитория может занять много времени — зависит от скорость вашего подключения к интернету. После перехода в директорию linux-git выполняем команду $git-checkout -f Теперь у нас есть доступ к текущему «сырому» дереву. Когда мы хотим обновить наш локальный репозиторий, введите $ git-pull git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git, а затем $ git-checkout Примечание! Когда мы хотим обновить локальный репозиторий, мы не должны делать это так: $ git-clone $ tree $ directory 29
30
ГЛАВА 4.GIT, QUILT И ДВОИЧНЫЙ ПОИСК
$ rm -rf $ каталог $ git-clone $ дерево $ каталог Используйте git-pull для обновления репозитория! Клонируя все дерево, мы тратим впустую ценные ресурсы ссылок на kernel.org (я пишу об этом только потому, что видел, как это делают некоторые люди). Добавление флага «-f» в git-checkout отменит все изменения, которые мы внесли в исходные файлы. Наиболее распространенные команды git, которые я использую: • git-whatchanged file — показывает все изменения, внесенные в данный файл • git-bisect * — поиск бинарного репозитория • git-pull * — загружает последнюю версию дерева • git -revert * - отменяет фиксацию (патч) • gitk - графическая программа визуализации дерева Очень полезной программой является git-log - она показывает список изменений, сделанных в дереве.Обычно мы будем использовать его так: $ git log Мы также можем перечислить все изменения, произошедшие с версии 2.6.19 $ git log v2.6.19 .. или за последние семь дней $ git log с = 7 дней назад С помощью git- show мы будем отображать интересующий нас коммит, например $git-show b5bf28cde894b3bb3bd25c13a7647020562f9ea0 Также стоит отметить, что нам не обязательно вводить/вставлять полное имя объекта — иногда достаточно первых нескольких символов. Так что мы получим тот же эффект с помощью $ git-show b5bf28 Очень полезное использование для git-show $ git-show b5bf28> latka.patch Это простой способ получить конкретный патч из дерева. Мы должны использовать протокол git:// для передачи объектов — он предназначен именно для этой цели. Однако в некоторых ситуациях (например, когда мы находимся за брандмауэром, который не можем настроить) мы можем использовать обычный протокол http://, но это не рекомендуемое решение. Большую коллекцию различных деревьев можно найти на http://git.kernel.org/ и http://git.infradead.org/. Для получения дополнительной информации о git см. http://git.or.cz/
4.2. QUILT
4.2
31
Quilt
Quilt - это инструмент для управления серией патчей, чаще всего такая серия применяется к определенной версии дерева Линуса, например 2.6.18-rc4. Мы можем установить его из пакета, поставляемого с дистрибутивом, или скачать его с сайта проекта https://savannah.nongnu.org/projects/quilt/. Самый быстрый способ применить исправления — скопировать их в каталог patches в исходном каталоге ядра, а затем скопировать файл серии в корневой каталог.Пример папки patches может содержать четыре файла: patch01.patch patch02.patch patch03.patch patch04.patch В файле серии патчи располагаются в том же порядке. Для применения всей серии нам нужно выполнить команду "quilt push -a" (или можно ввести название патча или его номер): $ quilt push -a $ quilt push patch04.patch $ quilt push 4 Если все хорошо, мы увидим серию сообщений: Применение патчей патчей / patch01.patch файл патчей include / linux / kernel.h файл патчей include / linux / memleak.h файл исправления init / main.c Применение патчей патчей / patch02.patch файл патчей arch / i386 / kernel / vmlinux.lds.S файл патчей include / asm-i386 / процессор.h Применение патчей патчей / patch03.patch файл патчей kernel / fork.c Применение патча patches / patch04.patch файл патча kernel / delayacct.c Теперь в patch patches / patch04.patch Когда мы хотим удалить все патчи, просто делаем "quilt pop -a". Мы также можем выбросить последние два патча, набрав: $ quilt pop patch02.patch Мы выбрасываем все патчи, примененные после файла «patch02.пластырь ". Благодаря этому мы можем легко выполнить бинарный поиск, о котором я напишу чуть позже. Управление патчами с помощью quilt осуществляется на основе стека FIFO, т.е. первый патч, указанный в файле серии, применяется первым. Когда мы хотим добавить наш патч в дерево, мы должны написать его на основе всего дерева (все патчи применены), а затем добавить его последним в файл серии. Это очень важно, особенно с очень большими деревьями, такими как -mm, потому что один файл может быть изменен более чем одним патчем.Их следует делать аддитивно.
32
4.3
ГЛАВА 4. GIT, QUILT И БИНАРНЫЙ ПОИСК
Бинарный поиск — идея вызывая это. Выкидывать патчи по одному было бы неразумно, поэтому делаем бинарный поиск. О чем это? У нас есть серия из десяти патчей: patch01.patch patch02.patch [..] patch10.patch Мы знаем, что собрав их все вместе, мы получим неправильную систему. Поэтому сначала наносим первую пятерку и проводим тест. Если ошибка не устранена, то она должна быть вызвана одним из этих пяти исправлений. Переворачиваем два последних патча (остаются первые три) и запускаем тест. Выяснилось, что бага больше нет, следует сделать вывод, что его вызвал четвертый или пятый патч. Применяем четвертый патч. Если была ошибка, то четвертый патч вызвал ее, в противном случае мы подозреваем пятый патч.Вышеприведенный пример иллюстрирует идею бинарного поиска, но не отражает его эффективности. Это очень много, потому что с каждым "проходом" мы отбраковываем половину патчей, которые нам предстоит протестировать - при более чем тысяче патчей (стандартный размер дерева - мм) первый "проход" отбраковывает более пятисот патчей! Бинарный поиск — это алгоритм класса O (log2N), поэтому мы можем легко вычислить (желательно с помощью калькулятора :), сколько раз нам придется пересобирать систему, чтобы найти патч для ошибки.
4.4
Бинарный поиск с помощью quilt
В файле серии перечислены следующие исправления: 01-kmemleak-base.patch 02-kmemleak-doc.patch 03-kmemleak-hooks.patch 04-kmemleak-modules.patch 05-kmemleak -i386.patch 06-kmemleak-arm.patch 07-kmemleak-false-positives.patch 08-kmemleak-keep-init.patch 09-kmemleak-test.patch 10-kmemleak-maintainers.patch #11-new-locking. patch # 12-new-locking-fix.patch 13-vt-memleak-fix.patch 14-new-locking-fix.patch 15-fix-for-prosible-leak-in-delayacctc.патч
4.4. БИНАРНЫЙ ПОИСК С QUILT
33
К сожалению, мы не можем собрать ядро после их всех слоев, поэтому мы выполняем бинарный поиск. Когда у нас есть только пятнадцать патчей, легче увидеть, какой из них изменяет файл, который не компилируется — «quilt patches some_file.c». Однако в случае с большими деревьями очень часто мы не сможем выбросить заплатки, находящиеся «внутри». Итак, мы начали с применения всех патчей $ quilt push -a Применение патчей patch patches/01-kmemleak-base.patch файл патча include /linux/kernel.h[..] файл патча kernel/delayacct.c Теперь на патч patches/15-fix-for-possible-leak-in-delayacctc.patch однако что-то пошло не так и мы не можем скомпилировать система. Скопируйте файл серии, например, в свой домашний каталог и откройте его в своем любимом текстовом редакторе, который отображает номер строки курсора. Выбираем патч, который находится посередине между 01-kmemleak-base.patch и 15-fix-for-possible-leak-in-delayacctc.patch был 07-kmemleak-false-positives.patch Мы отзываем патчи после 07-kmemleak-false-positives.patch. $ quilt pop 07-kmemleak-false-positives.patch Удаление патчей patch /15-fix-for-possible-leak-in-delayacctc.patch Восстановление include/linux/delayacct.h[..] Восстановление lib/Kconfig.debug Now at patch patches / 07-kmemleak-false-positives.patch Ошибка все еще существует? Напишите "ПЛОХО" серию "ПЛОХО" после седьмой поправки к копии файла и снова выберите патч. Наш выбор пал на 04-kmemleak-modules.patch$ quilt pop 04-kmemleak-modules.патч Ошибка исчезла? Вводим "GOOD" после четвертой поправки, осталось всего три $ quilt push 06-kmemleak-arm.patch и так пока не дойдем до 06-kmemleak-arm.patch GOOD 07-kmemleak-false-positives.patch BAD В "Как выполнить поиск пополам в деревьях -mm" http://www.zip.com.au/~akpm/linux/patches/stuff/bisecting-mm-trees.txt Эндрю Мортон советует не делить при поиске двоичных файлов в - mmtrees patches
34
ГЛАВА 4. GIT, QUILT И ДВОИЧНЫЙ ПОИСК
patch-blah.patch бла-бла-fix3.patch patch бла-бла-fix1.patch patch бла-бла-fix2.patch patch бла-бла-fix3.patch patch давайте применим все или не будем применять ничего. В следующем видео показан практический пример использования бинарного поиска quilt http://www.youtube.com/watch?v=LS_hTnBDIYk
4.5
Бинарный поиск с помощью git-bisect
Git-bisect — мой любимый инструмент бинарного поиска. настоящее убойное приложение. 18-rc5 столкнулся с небольшой проблемой, и мы не знаем точно, какая фиксация ее вызвала, но мы знаем, что версия 2.6.18-rc4 работал нормально. Начинаем наш поиск: $ git-bisect start Отмечаем текущую версию как плохую $ git-bisect bad Version 2.6.18-rc4 (благодаря gitk узнаем, что это commit 9f737633e6ee54fc174282d49b2559bd2208391d) Теперь отметим как хорошую: $ git7d378391d9 goodfee7db6334 goodfee7db6174 goodfee7db6334d выберет промежуточную версию. Он выбрал: Разделение пополам: осталось 202 ревизии для тестирования после этого [c5ab964debe92d0ec7af330f350a3433c1b5b61e] speck_cs: исправить ошибки загрузки прошивки Мы можем визуализировать дерево с помощью команды "git-bisect visualize".Затем мы собираем и тестируем систему. Допустим, ошибка все еще возникает, поэтому мы помечаем текущую версию как плохую, git-bisect выберет для нас нового кандидата. $ git-bisect bad Bisecting: 101 ревизия осталась для тестирования после этого [1d7ea7324ae7a59f8e17e4ba76a2707c1e6f24d2] fuse: исправить случай ошибки в fuse_readpages Сборка, тестирование и т.д. Оказалось, что бага больше нет, поэтому помечаем эту версию как хорошую: git- bisect good Bisecting : осталось 55 ревизий для тестирования после этого6 Продолжаем весь процесс, пока не получим сообщение похожее на следующее
4.6. ATTENTION ON "MAKE OLDCONFIG"
35
$ git-bisect good 1d7ea7324ae7a59f8e17e4ba76a2707c1e6f24d2 is first bad commit commit 1d7ea7324ae7a59f8e17e4ba76a2707c1e: f8e17e4ba76a2707c1e: error6F24dski24: error in August 2006 Author: Janf24dski24: Don't let fuse_readpages leave the @pages list not empty when exiting по ошибке. [..] У него есть номер коммита, который вводит нас в заблуждение.Чтобы убедиться, что все работает нормально без этого патча, нам нужно сбросить git-bisect (мы вернемся к 2.6.18-rc5) и выбросить плохой коммит. git-bisect reset git-revert 1d7ea7324ae7a59f8e17e4ba76a2707c1e6f24d2 При поиске бинарного файла с помощью git-bisect мы чаще всего будем использовать следующие команды: • git-bisect start — запускает процесс поиска • git-bisect reset — завершает процесс • git-bisect good — означает, что текущая версия хорошая, мы можем передать ее как параметр фиксации • git-bisect bad — означает, что текущая версия плохая, мы можем передать ее как параметр фиксации • git-bisect visualize — включает «gitk» и показывает исправления между последней хорошей и плохую версию я также рекомендую прочитать "man git-"bisect" - там описаны дополнительные опции.В следующем видео показан практический пример использования бинарного поиска с помощью git-bisect http://www.youtube.com/watch?v=R7_LY-ceFbE
4.6
Примечание о «make oldconfig»
При выполнении бинарного поиска вам нужно помнить об одной очень важной вещи - не используйте "make oldconfig"! Это связано с тем, что с новыми патчами появляются новые опции (иногда они также исчезают) — например, когда мы возвращаемся к пятидесяти патчам и обнаруживаем, что данная версия работает хорошо, мы применяем еще двадцать пять патчей.Теперь мы можем не помнить, что ранее была включена опция XY - если мы не включим ее снова, ошибка может больше не появляться... Это очень распространенная ошибка, во время
36
ГЛАВА 4. GIT, QUILT AND SEARCH BINARY
бинарный поиск, так что имейте это в виду. Поэтому лучше всего скопировать наш файл конфигурации ядра в другой каталог перед запуском бинарного поиска и копировать его в исходный каталог ядра каждый раз перед компиляцией.Это должно уберечь нас от ошибок.
Глава 5 Сообщения об ошибках Сообщения об ошибках ядра следует отправлять в LKML, в список подсистем (если таковой существует — все списки перечислены на http://vger.kernel.Org/vger-lists.html) и в сопровождающий код, в котором произошел дефект. Если мы знаем, какой патч вызвал проблему, мы должны сообщить об этом разработчикам - лучше всего отправить информацию всем, кто указан в информационных полях "От:", "Подписано:", "Подтверждено:" ( тем самым увеличивая вероятность быстрого ответа).Иногда наш отчет может быть съеден антиспам-фильтром, либо он теряется где-то в недрах почтовых ящиков разработчиков (некоторые из них получают очень много писем, так что не удивляйтесь, что иногда они что-то пропускают), поэтому если мы не получили ответа в течение нескольких дней, мы должны отправить его повторно. Если все равно никто не ответил на наш отчет, наиболее подходящим способом действий было бы опубликовать его на странице bugzilla http://bugzilla.kernel.org/. Хороший отчет должен содержать: • сообщаемую ошибку • файл конфигурации нашего ядра • информацию, необходимую для воспроизведения ошибки • информацию о конфигурации нашего оборудования (при необходимости, например,для проблем с некоторыми драйверами) Для получения дополнительной информации см. ОТЧЕТЫ-ОШИБКИ. Включив CONFIG_DEBUG_INFO, мы сможем предоставить дополнительную информацию для обнаружения ошибки. Во время тестирования по возможности (в основном по поводу производительности системы, а точнее ее отсутствия после включения некоторых опций) включить какие-то "фичи" в меню "Взлом ядра --->". После сообщения об ошибке мы, скорее всего, получим исправление для тестирования. Если проблема не устранена после его применения, сообщите об этом разработчику, который отправил нам его.Если патч решит проблему, все, что нам нужно сделать, это поблагодарить разработчика. ОРТ — это инструмент, задача которого облегчить подготовку хорошего баг-репорта. После запуска: 37
38
ГЛАВА 5. ОТЧЕТЫ О ОШИБКАХ
$ ./ort.sh oops.txt У нас спросят тип отчета: • краткий — только основная информация • пользовательский — можем выбрать что хотим вставить в отчет • template - шаблон отчета Далее вводим необходимую информацию, выбираем нужные нам параметры.Отчет формируется по шаблону, который можно найти в REPORTING-BUGS. Последнюю версию ОРТ можно найти по адресу: http://www.stardust.webpages.pl/ltg/files/tools/ort/ Недостатком этого инструмента является то, что мы можем легко предоставить много ненужной информации.
Глава 6 Тестирование аппаратного обеспечения Прежде чем приступить к первым тестам, важно помнить, что необходимо проверить аппаратное обеспечение — нам нужно убедиться, что оно работает правильно. На самом деле должно быть достаточно разового надлежащего тестирования всех компонентов нашего компьютера.Позже, когда возникнут какие-либо сомнения, например, в работе жесткого диска, мы можем проверить его еще раз (жесткие диски иногда дают сбой). Для выполнения тестов памяти можно использовать программу Memtest86+. Рекомендую скачать iso-образ с сайта проекта http://www.memtest.org/ и запустить программу с компакт-диска. Вы также можете использовать старую программу Memtest86 http://www.memtest86.com/ или любую другую программу, которая хорошо справляется с этой задачей. Сканирование поверхности диска на наличие поврежденных участков можно выполнить с помощью стандартных «бэдблоков».Ввод # /sbin/badblocks -v /dev/disk должен быстро сказать нам, так ли функционален наш диск, как нам хотелось бы. Дополнительную информацию о состоянии диска можно получить, выполнив тест с помощью теста S.M.A.R.T. # smartctl --test=long/dev/disk Результат теста можно посмотреть введя команду # smartctl -a /dev/disk Если мы разгоняем процессор, память и т.д. мы должны отказаться от него на время испытаний. Разгон вашего оборудования может внести искажения и вызвать различные случайные ошибки.Стоит проверить правильность питающих компоненты нашего компьютера напряжений, тут нам на помощь придет программа lm_sensors. Мы также можем использовать программу, предоставленную производителем материнской платы (к сожалению, обычно это версия только для Windows), которая часто позволяет проводить дополнительную диагностику. Кроме того, следует помнить о возникновении различных случайных ошибок, связанных с оборудованием, а не обязательно по его вине - например, в результате электромагнитного или космического излучения.На 100% защититься от таких ошибок невозможно, но производители оборудования используют различные технологии, например, оперативную память с ECC, проверку контрольных сумм передаваемых байтов по шинам и т.д. предназначен для уменьшения возникновения проблем, связанных с повреждением данных. 39
40
ГЛАВА 6. ТЕСТИРОВАНИЕ АППАРАТНОГО ОБЕСПЕЧЕНИЯ
Другой категорией аппаратных ошибок являются MCE (Machine Check Exception), генерируемые процессором, который таким образом уведомляет систему, например, об ошибке.о проблеме с внутренней кэш-памятью, недопустимом перегреве и т.п. При обнаружении такой ошибки система считалась «загрязненной» и добавлялась буква «М» в строку, содержащую информацию EIP в oops (EIP:0060:[]Tainted: PM VLI). С помощью комплекта разработчика прошивки для Linux http://www.linuxfirmwarekit.org/ мы можем проверить наличие серьезных ошибок в BIOS нашего компьютера. Хотя мы мало что сможем с этим поделать — кроме обновления до последней версии и, возможно, уведомления производителя оборудования, мы будем знать об ошибках.Это может помочь нам позже определить, связана ли проблема с оборудованием или с операционной системой.
Приложение A Приложение A A.1
Отправка исправлений
Вы хотите отправить исправление для исправления найденной ошибки? Прочтите Документацию/Отправку исправлений и обратите особое внимание на РАЗДЕЛ 3 - ССЫЛКИ. Есть ссылки на документы, которые следует прочитать перед отправкой патча. Не забудьте отключить перенос текста в почтовом клиенте. Некоторые почтовые программы, например.Thunderbird любит заменять пробелы на другие пробелы — установка расширения шифрования обычно решает эти проблемы (если вы хотите использовать Thunderbird для отправки исправлений, я рекомендую прочитать http://mbligh.org/linuxdocs/Email/Clients/Thunderbird). Если вы хотите отправить целую серию патчей, лучше использовать http://www.aepfle.de/scripts/42_send_patch_mail.sh. Если не хотите во всем разбираться, вот краткая инструкция: • установить sendmail и mutt • в начале скрипта набрать «sudo /etc/init.d /sendmail start» и, наконец, «sudo /etc/init.d/sendmail stop» — это ограничит время, необходимое для открытия потенциальной дыры в системе (у sendmail очень длинная история уязвимостей). • в файле .muttrc введите «set realname = ‘Имя Фамилия’» и «set from = some [email protected]» • в 99-й строке скрипта измените адрес -bcc на свой • измените имя хоста на имя шлюза, то вы не будете получать ответные письма ----- На следующих адресах были постоянные фатальные ошибки ---- (причина: 553 5.1.8 ... Домен адреса отправителя некто [email protected] Ś2.com не существует) [..] 41
42
ПРИЛОЖЕНИЕ A. ПРИЛОЖЕНИЕ A
Теперь вам нужно создать файл, который будет отправлен как [PATCH 0 / x], его формат следующий: Тема: Некоторые Тема Кому: some_address @list.com Копия: adres_jakiegoś@odbiorcy1.com, adres_jakiegoś@odbiorcy2.com Описание патчей, diffstat и т. д. Мы также добавляем подобный заголовок в начале каждого патча. Затем создаем файл с серией патчей (так же, как и для quilt) и можем отправить все патчи: $42_send_patch_mail.sh -d файл_сообщения.txt -s файл_патча Интересный скрипт для отправки патчей тоже есть http://www.speakeasy.org/~pj99/sgi/sendpatchset - его неоспоримое преимущество в том, что он не требует установки sendmail и mutt. Вам нужно только создать управляющий файл: SMTP: server_address.smtp.z.któ [email protected] From: Имя и фамилия To: Recipient1 Cc: Recipient2 Cc: Recipient3 Subject: [PATCH 1 / n] Описание первого patch Файл: path-to-patches Тема: [PATCH n / n] Описание последнего патча File: path-to-last-patch Затем отправьте исправления: $ sendpatchset control
A.2
Тестовая система
Наша тестовая система должна быть отделена от системы, с которой мы обычно работаем - мы не должны монтировать в нее какие-либо разделы из стабильной системы. Таким образом, если мы обнаружим серьезную ошибку в файловой системе или другой подсистеме ядра с потерей данных, наша стабильная система не должна от этого пострадать. Если новое ядро разрушает нашу тестовую систему, мы обнаружили серьезную ошибку, о которой мы должны уведомить разработчиков системы.Еще одна вещь, о которой следует помнить, это то, что мы можем работать на системе, отличной от стабильной системы. Просто смонтируйте раздел куда-нибудь в /mnt, а затем выполните chroot в другую систему. Теперь мы можем подготовить новое ядро, скомпилировать и установить его (желательно с помощью какого-нибудь скрипта, который все сделает за нас), не отвлекаясь от своей обычной деятельности. Как только мы нашли время, мы можем перезагрузить систему и перейти к тестовой системе. При выборе дистрибутива, служащего нам тестовой системой, мы должны руководствоваться только своим удобством — он должен облегчить нашу работу, а не создавать дополнительный.Когда
А.3. KLIVE
43
мы тестируем новые версии ядра, мы также хотели бы протестировать его новый функционал, поэтому приятно, когда в дистрибутиве предлагаются новые версии инструментов и библиотек. Хорошим выбором является тестовая версия Debian — в ней есть текущие версии инструментов и более старые версии gcc (к сожалению, не все разработчики проверяют, работает ли их код после компиляции с другой версией gcc, чем та, которая поставляется с их любимым дистрибутивом). ). Fedora Core имеет очень хорошую поддержку SELinux и все новости, которые предлагают последние версии ядра.
A.3
KLive
KLive — это инструмент, с помощью которого разработчики Linux могут узнать, как долго тестировалось данное дерево. Почему вы должны его использовать? Линус Торвальдс объявил о выпуске 2.6.15-rc5: «Сейчас есть rc5, в основном потому, что я не буду общаться по электронной почте в течение следующей недели, и хотя я бы хотел, чтобы люди неукоснительно проверяли все ночные снимки, дело в том, что вы, ребята, этого не делаете». Разработчики не ясновидящие и не знают, сколько человек тестировало тот или иной релиз и как долго - иногда бывает, что все работает как надо и никто не сообщает об ошибках - тогда мейнтейнер дерева не уверен, тестировал ли кто-то данный релиз .Если вы хотите начать пользоваться KLive, в начале предлагаю вам посетить сайт проекта http://klive.cpushare.com/ - там вы сможете найти информацию о том, как работать и установить программу (последняя очень проста, вы просто нужно установить необходимые пакеты, а затем скачать и запустить скрипт (sh klive.sh --install)
A.4
Как стать Linux-разработчиком
Иногда LKML задает этот вопрос (не буду отвечать это по простой причине, я не разработчик), поэтому Грег КроаХартман написал короткую статью на эту тему.Если вы хотите узнать ответ на этот вопрос, просто прочитайте документацию / HOWTO :).
44
ПРИЛОЖЕНИЕ A. ПРИЛОЖЕНИЕ A
ПРИЛОЖЕНИЕ B ПРИЛОЖЕНИЕ B B.1
Как вы можете помочь в дальнейшей разработке этого руководства?
«Исходную» версию руководства можно найти по адресу: http://www.stardust.webpages.pl/ltg/files/handbook-current.tar.bz2 (прежде чем приступать к модификации, стоит проверить, у тебя последняя). После внесения изменений просто выполните $diff -uprN ver-original/handbook.tex \\modified-version/handbook.tex> patch.patch и отправьте его на [email protected] (для серьезных изменений, пожалуйста, также добавьте CC в список рассылки LTG).
B.2
Где я могу получить помощь в тестировании?
Если вам нужна помощь в решении проблемы с ядром Linux или если вы сомневаетесь, нашли ли вы ошибку, не стесняйтесь задавать любые вопросы! Страница помощи в вики http://www.stardust.webpages.pl/ltg/wiki/index.php/ Страница помощи списка обсуждений http://groups.google.com/group/linux-testers-group-en
B.3
Немного о группе тестировщиков Linux
Итак, ответы на ранее незаданные вопросы. В: Что делает LTG? A: Тестирование ядра Linux. В: Как я могу присоединиться к LTG? О: Просто начните тестирование... В: Где какая-то домашняя страница? О: На http://www.stardust.webpages.pl/ltg/ В: Есть ли список рассылки? О: Конечно – по адресу http://groups.google.com/group/linux-testers-group-en 45
46
ПРИЛОЖЕНИЕ B.ПРИЛОЖЕНИЕ B
B.4
Причины распространения ошибок в стабильных версиях Linux
Следующая статья была написана для журнала Dragonia. Я не собираюсь раскрывать информацию, когда пишу, что в Linux много ошибок. Но откуда именно они берутся и как предотвратить их распространение на стабильные версии системы? Я постараюсь ответить на этот вопрос в статье ниже. В начале нам предстоит ответить на простой вопрос — что за ошибка в программе? Программная ошибка – это непреднамеренная (бывают случаи преднамеренной) ошибка программиста, в результате которой происходит некорректная работа программы.Эта неисправность может проявляться по-разному: • зависание программы • выдаются неверные результаты расчетов • возможность захвата программы взломщиком • фальсификация/искажение входных и/или выходных данных • неэффективные/неэффективные алгоритмы • утечки памяти, гоночные ситуации и т.п. Ошибка может возникнуть в результате ошибки при написании исходного кода программы, а также на этапе планирования ее модели. Также бывают ситуации, в которых ошибка возникает из-за некорректной работы инструментов, используемых для компиляции программы.Ошибки, возникающие на этапе написания исходного кода, часто гораздо проще устранить, чем те, которые возникают на этапе планирования модели программы. Неверные решения, принятые на этом этапе, могут привести к ошибкам, которые очень трудно устранить. Каковы основные причины ошибок Linux? Основная причина в том, что это большой и сложный проект, поэтому большинство людей, работающих над системой, сосредотачиваются на своих любимых подсистемах, с которыми они знакомы.Проблема возникает, когда кто-то пытается модифицировать код, который он плохо знает и не до конца понимает. Поэтому многие ошибки вызваны людьми, которые регулярно имеют дело с Linux. Другая причина — это то, что называется «Новая модель развития» http://www.stardust. webpages.pl/ltg/wiki/index.php/Proces_rozkieta_j%C4%85dra_Linux. В прошлом Linux разрабатывался по принципам, аналогичным тем, на которых разрабатывается обычное программное обеспечение:2.2.x)
B.4. ПРИЧИНЫ РАСПРОСТРАНЕНИЯ ОШИБОК В СТАБИЛЬНЫХ ВЕРСИЯХ LINUX 47 • цикл разработки, в ходе которого добавляются новые функции с последующей попыткой стабилизации (например, версии 2.3.x) • последующие стабильные выпуски (например, версии 2.4.x) Однако, начиная с версии 2.6. 8 изменилась модель разработки и теперь она выглядит так (на примере версии 2.6.20 и 2.6.21): • выпуск стабильной версии 2.6.20, далее публикуются патчи с пометкой 2.6.20.x • работающая на новую версию, добавление нового функционала - 2.6.20-gitX (обычно около двух недель) • завершение разрабатываемой версии, начало цикла стабилизации — 2.6.21-rcX • выпуск стабильной версии 2.6.21 Эта модель ускоренной разработки имеет свои преимущества и недостатки. Недостатком является то, что он развивается очень быстро, поэтому многие ошибки могут переходить из стадии разработки в стабильную версию. К плюсам можно отнести то, что не приходится долго ждать нового функционала (старые нестабильные версии разрабатывались долго, а первые стабильные обычно трудно было считать таковыми).В чем причина системных ошибок безопасности в Linux? В отличной книге "Безопасное программирование для Linux и Unix HOWTO" http: // www. dwheeler.com/secure-programs/ Дэвид А. Уилер перечислил несколько причин для http: // www. dwheeler.com/secure-programs/Secure-Programs-HOWTO.html#WHY-WRITE-INSECURE, из-за которых в программах есть ошибки, которыми могут воспользоваться взломщики. Со своей стороны добавлю лишь одну причину, которой не было в этом списке — малое количество подходящих программ (или их неэффективность) для помощи в обнаружении потенциальных уязвимостей.Разработчики Linux придают большое значение качеству кода. Перед тем, как отправить новый код на проверку, разработчик должен убедиться, что он соответствует всем требованиям, перечисленным в Документация / Контрольный список. Затем код читается другими разработчиками, которые присылают свои комментарии — чаще всего по поводу: • стиля кодирования — стиль кодирования в Linux должен быть единым — это очень важно, так как это облегчает чтение и понимание кода (вы можете прочитать его читая Documentation/CodingStyle ) • используемые алгоритмы — все хотят, чтобы они были максимально эффективными при просмотре кода.Следующим шагом является проверка кода в дереве подсистем или -mm, где это
48
ПРИЛОЖЕНИЕ Б. ПРИЛОЖЕНИЕ Б
проверяется на совместимость с другими частями ядра системы. Это очень важный этап, потому что он должен отлавливать все более серьезные ошибки. Затем код включается в разрабатываемую версию дерева Линуса, и там предпринимается последняя попытка его стабилизации. Встроить код в Linux не так просто — он должен соответствовать определенным стандартам.Чаще всего это происходит через так называемую «сеть доверия» — код включается в дерево данной подсистемы и только потом переходит в основную ветку. Причина этого в том, что у Линуса Торвальдса нет времени читать каждый сделанный патч, и он предполагает, что сопровождающие подсистемы лучше знают, как они должны выглядеть, и что включенные патчи уже были должным образом протестированы. Процесс качества кода в Linux очень строг — гораздо строже, чем в других проектах.Так почему же так много ошибок попадает в стабильные версии? Последний «стабильный» патч 2.6.20.2 состоит из более сотни патчей, которые устраняют определенные проблемы. Ответ очень прост — недостаточно людей тратят время на тестирование и исправление ошибок в новом функционале. Одни считают, что средством от этих проблем должен стать возврат к старой модели разработки, но она имеет очень серьезные недостатки: • приходится долго ждать новой функциональности (последний большой цикл разработки 2.5.x - длилась более двух лет!) • разработчики несут дополнительные временные затраты, связанные с переносом нового функционала в ядра стабильных дистрибутивов - это время могло быть потрачено на его создание, исправление ошибок и т.д. • длительное время, необходимое для стабилизации после длительного цикла разработки. Как видите, новая модель разработки имеет серьезные преимущества, но без достаточного количества людей, тестирующих разрабатываемые версии, она не будет работать. Дело очень сложное, потому что разработчики не могут исправлять ошибки, о существовании которых они не знают.Большинство проблем возникают только тогда, когда другие люди начинают использовать код. Ситуация может ухудшиться до такой степени, что новые стабильные версии Linux будут хорошо работать только на машинах с такой же конфигурацией, на которой тестировались их разрабатываемые версии. В дополнение к увеличению числа людей, тестирующих код, хорошей идеей может быть снижение скорости изменений. Однако действительно ли мы этого хотим? С одной стороны, торможение развития Linux может очень положительно сказаться на его стабильности, с другой стороны, вы должны учитывать, что все необходимые новые функции будут входить в него с возрастающим опозданием.Приглашаю всех, кто заинтересован в изменении такого положения вещей, к сотрудничеству и обсуждению в нашем списке http://groups.google.com/group/linux-testers-group-pl.
Б.5. ЛИЦЕНЗИЯ
B.5
49
Лицензия
Авторство 2.5 Польша Вам разрешается: • копировать, распространять, воспроизводить и исполнять произведение • создавать производные произведения • использовать произведение в коммерческих целях При следующих условиях: • Атрибуция. Произведение должно быть помечено способом, установленным Создателем или Лицензиаром • Чтобы повторно использовать произведение или распространять произведение, объясните другим условия лицензии, по которой произведение доступно.• От любого из этих условий можно отказаться с разрешения владельца авторских прав. Вышеуказанные положения никоим образом не затрагивают права, возникающие в результате добросовестного использования, или любые другие права. http://creativecommons.org/licenses/by/2.5/en/legalcode Конечно, если лицензия CC вам не подходит, вы можете использовать любую лицензию, считающуюся открытой http://www.opensource.org/licenses / до тех пор, пока вы ведете записи об авторах и людях, внесших вклад в это руководство.
50
ПРИЛОЖЕНИЕ B. ПРИЛОЖЕНИЕ B
.
Видео-курс
