Структура модуля ядра и методы его компиляции. Конфигурирование и компиляция ядра Linux. Явное определение функций завершения и инициализации

Linux предоставляет мощный и обширный API для приложений, но иногда его недостаточно. Для взаимодействия с оборудованием или осуществления операций с доступом к привилегированной информации в системе нужен драйвер ядра.

Модуль ядра Linux - это скомпилированный двоичный код, который вставляется непосредственно в ядро Linux, работая в кольце 0, внутреннем и наименее защищённом кольце выполнения команд в процессоре x86–64. Здесь код исполняется совершенно без всяких проверок, но зато на невероятной скорости и с доступом к любым ресурсам системы.

Не для простых смертных

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

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

Можно в основном забыть традиционные парадигмы разработки приложений. Кроме загрузки и выгрузки модуля, вы будете писать код, который реагирует на системные события, а не работает по последовательному шаблону. При работе с ядром вы пишете API, а не сами приложения.

У вас также нет доступа к стандартной библиотеке. Хотя ядро предоставляет некоторые функции вроде printk (которая служит заменой printf) и kmalloc (работает похоже на malloc), в основном вы остаётесь наедине с железом. Вдобавок, после выгрузки модуля следует полностью почистить за собой. Здесь нет сборки мусора.

Необходимые компоненты

Прежде чем начать, следует убедиться в наличии всех необходимых инструментов для работы. Самое главное, нужна машина под Linux. Знаю, это неожиданно! Хотя подойдёт любой дистрибутив Linux, в этом примере я использую Ubuntu 16.04 LTS, так что в случае использования других дистрибутивов может понадобиться слегка изменить команды установки.

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

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

Установка среды разработки

На Ubuntu нужно запустить:

Apt-get install build-essential linux-headers-`uname -r`
Устанавливаем самые важные инструменты разработки и заголовки ядра, необходимые для данного примера.

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

Начинаем

Приступим к написанию кода. Подготовим нашу среду:

Mkdir ~/src/lkm_example cd ~/src/lkm_example
Запустите любимый редактор (в моём случае это vim) и создайте файл lkm_example.c следующего содержания:

#include #include #include MODULE_LICENSE(“GPL”); MODULE_AUTHOR(“Robert W. Oliver II”); MODULE_DESCRIPTION(“A simple example Linux module.”); MODULE_VERSION(“0.01”); static int __init lkm_example_init(void) { printk(KERN_INFO “Hello, World!\n”); return 0; } static void __exit lkm_example_exit(void) { printk(KERN_INFO “Goodbye, World!\n”); } module_init(lkm_example_init); module_exit(lkm_example_exit);
Мы сконструировали самый простой возможный модуль, рассмотрим подробнее самые важные его части:

В include перечислены файлы заголовков, необходимые для разработки ядра Linux.
В MODULE_LICENSE можно установить разные значения, в зависимости от лицензии модуля. Для просмотра полного списка запустите:
Grep “MODULE_LICENSE” -B 27 /usr/src/linux-headers-`uname -r`/include/linux/module.h
Мы устанавливаем init (загрузка) и exit (выгрузка) как статические функции, которые возвращают целые числа.
Обратите внимание на использование printk вместо printf . Также параметры printk отличаются от printf . Например, флаг KERN_INFO для объявления приоритета журналирования для конкретной строки указывается без запятой. Ядро разбирается с этими вещами внутри функции printk для экономии памяти стека.
В конце файла можно вызвать module_init и module_exit и указать функции загрузки и выгрузки. Это даёт возможность произвольного именования функций.

Впрочем, пока мы не можем скомпилировать этот файл. Нужен Makefile. Такого базового примера пока достаточно. Обратите внимание, что make очень привередлив к пробелам и табам, так что убедитесь, что используете табы вместо пробелов где положено.

Obj-m += lkm_example.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean
Если мы запускаем make , он должен успешно скомпилировать наш модуль. Результатом станет файл lkm_example.ko . Если выскакивают какие-то ошибки, проверьте, что кавычки в исходном коде установлены корректно, а не случайно в кодировке UTF-8.

Теперь можно внедрить модуль и проверить его. Для этого запускаем:

Sudo insmod lkm_example.ko
Если всё нормально, то вы ничего не увидите. Функция printk обеспечивает выдачу не в консоль, а в журнал ядра. Для просмотра нужно запустить:

Sudo dmesg
Вы должны увидеть строку “Hello, World!” с меткой времени в начале. Это значит, что наш модуль ядра загрузился и успешно сделал запись в журнал ядра. Мы можем также проверить, что модуль ещё в памяти:

Lsmod | grep “lkm_example”
Для удаления модуля запускаем:

Sudo rmmod lkm_example
Если вы снова запустите dmesg, то увидите в журнале запись “Goodbye, World!”. Можно снова запустить lsmod и убедиться, что модуль выгрузился.

Как видите, эта процедура тестирования слегка утомительна, но её можно автоматизировать, добавив:

Test: sudo dmesg -C sudo insmod lkm_example.ko sudo rmmod lkm_example.ko dmesg
в конце Makefile, а потом запустив:

Make test
для тестирования модуля и проверки выдачи в журнал ядра без необходимости запускать отдельные команды.

Теперь у нас есть полностью функциональный, хотя и абсолютно тривиальный модуль ядра!

Копнём чуть глубже. Хотя модули ядра способны выполнять все виды задач, взаимодействие с приложениями - один из самых распространённых вариантов использования.

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

Вероятно, раньше вы уже имели дело с файлами устройств. Команды с упоминанием /dev/zero , /dev/null и тому подобного взаимодействуют с устройствами “zero” и “null”, которые возвращают ожидаемые значения.

В нашем примере мы возвращаем “Hello, World”. Хотя это не особенно полезная функция для приложений, она всё равно демонстрирует процесс взаимодействия с приложением через файл устройства.

Вот полный листинг:

#include #include #include #include #include MODULE_LICENSE(“GPL”); MODULE_AUTHOR(“Robert W. Oliver II”); MODULE_DESCRIPTION(“A simple example Linux module.”); MODULE_VERSION(“0.01”); #define DEVICE_NAME “lkm_example” #define EXAMPLE_MSG “Hello, World!\n” #define MSG_BUFFER_LEN 15 /* Prototypes for device functions */ static int device_open(struct inode *, struct file *); static int device_release(struct inode *, struct file *); static ssize_t device_read(struct file *, char *, size_t, loff_t *); static ssize_t device_write(struct file *, const char *, size_t, loff_t *); static int major_num; static int device_open_count = 0; static char msg_buffer; static char *msg_ptr; /* This structure points to all of the device functions */ static struct file_operations file_ops = { .read = device_read, .write = device_write, .open = device_open, .release = device_release }; /* When a process reads from our device, this gets called. */ static ssize_t device_read(struct file *flip, char *buffer, size_t len, loff_t *offset) { int bytes_read = 0; /* If we’re at the end, loop back to the beginning */ if (*msg_ptr == 0) { msg_ptr = msg_buffer; } /* Put data in the buffer */ while (len && *msg_ptr) { /* Buffer is in user data, not kernel, so you can’t just reference * with a pointer. The function put_user handles this for us */ put_user(*(msg_ptr++), buffer++); len--; bytes_read++; } return bytes_read; } /* Called when a process tries to write to our device */ static ssize_t device_write(struct file *flip, const char *buffer, size_t len, loff_t *offset) { /* This is a read-only device */ printk(KERN_ALERT “This operation is not supported.\n”); return -EINVAL; } /* Called when a process opens our device */ static int device_open(struct inode *inode, struct file *file) { /* If device is open, return busy */ if (device_open_count) { return -EBUSY; } device_open_count++; try_module_get(THIS_MODULE); return 0; } /* Called when a process closes our device */ static int device_release(struct inode *inode, struct file *file) { /* Decrement the open counter and usage count. Without this, the module would not unload. */ device_open_count--; module_put(THIS_MODULE); return 0; } static int __init lkm_example_init(void) { /* Fill buffer with our message */ strncpy(msg_buffer, EXAMPLE_MSG, MSG_BUFFER_LEN); /* Set the msg_ptr to the buffer */ msg_ptr = msg_buffer; /* Try to register character device */ major_num = register_chrdev(0, “lkm_example”, &file_ops); if (major_num < 0) { printk(KERN_ALERT “Could not register device: %d\n”, major_num); return major_num; } else { printk(KERN_INFO “lkm_example module loaded with device major number %d\n”, major_num); return 0; } } static void __exit lkm_example_exit(void) { /* Remember - we have to clean up after ourselves. Unregister the character device. */ unregister_chrdev(major_num, DEVICE_NAME); printk(KERN_INFO “Goodbye, World!\n”); } /* Register module functions */ module_init(lkm_example_init); module_exit(lkm_example_exit);

Тестирование улучшенного примера

Теперь наш пример делает нечто большее, чем просто вывод сообщения при загрузке и выгрузке, так что понадобится менее строгая процедура тестирования. Изменим Makefile только для загрузки модуля, без его выгрузки.

Obj-m += lkm_example.o all: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) modules clean: make -C /lib/modules/$(shell uname -r)/build M=$(PWD) clean test: # We put a - in front of the rmmod command to tell make to ignore # an error in case the module isn’t loaded. -sudo rmmod lkm_example # Clear the kernel log without echo sudo dmesg -C # Insert the module sudo insmod lkm_example.ko # Display the kernel log dmesg
Теперь после запуска make test вы увидите выдачу старшего номера устройства. В нашем примере его автоматически присваивает ядро. Однако этот номер нужен для создания нового устройства.

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

Sudo mknod /dev/lkm_example c MAJOR 0
(в этом примере замените MAJOR значением, полученным в результате выполнения make test или dmesg)

Параметр c в команде mknod говорит mknod, что нам нужно создать файл символьного устройства.

Теперь мы можем получить содержимое с устройства:

Cat /dev/lkm_example
или даже через команду dd:

Dd if=/dev/lkm_example of=test bs=14 count=100
Вы также можете получить доступ к этому файлу из приложений. Это необязательно должны быть скомпилированные приложения - даже у скриптов Python, Ruby и PHP есть доступ к этим данным.

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

Sudo rm /dev/lkm_example sudo rmmod lkm_example

Заключение

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

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

Linux: Полное руководство Колисниченко Денис Николаевич

28.2. Компиляция модуля

Компилировать мы будем файл module.c. Для этого понадобится установленный компилятор gcc, заголовочные файлы и исходные тексты ядра. Если вы дочитали книгу до этой главы, то у вас уже должны быть установлены пакеты:

1. cpp - препроцессор cpp;

2. binutils - набор различных утилит (as, gprof, ld);

3. glibc-kerheaders - заголовочные файлы ядра;

4. glibc-devel - вспомогательные файлы для разработки приложений с использованием стандартной библиотеки С;

5. gcc - компилятор gcc.

Осталось установить пакет kernel-source - исходные тексты ядра Linux. Кроме того, нужно убедиться, что ваше ядро поддерживает динамически загружаемые модули (п. 20.3.2.3). Если опция Enable loadable module support выключена , ее нужно включить, сохранить файл конфигурации ядра и перекомпилировать ядро.

Компилятор gcc нужно вызвать со множеством опций, поэтому для облегчения себе работы мы напишем make-файл (п. 21.2):

Листинг 28.5. Makefile для сборки модуля

PATH=/usr/include /usr/src/linux-2.4/include

MODFLAGS:= -O3 -Wall -DLINUX -D__KERNEL__ -I$(PATH)

module.o: module.с

$(CC) $(MODFLAGS) -c module.с

Опции компилятора означают следующее:

O3: будет использован третий уровень оптимизации (что это такое, вы узнаете в справочной системе gcc : man gcc);

Wall: включаем все предупреждения;

DLINUX: генерируем код для Linux;

I$(РАТН): определяем путь поиска заголовочных файлов. По умолчанию компилятор ищет файлы заголовков в каталоге /usr/include, но там может и не быть нужных файлов. Например, для дистрибутива ALT Linux (ядро 2.4.21) файлы заголовков находятся в каталоге /usr/include/linux-2.4.21rel-std-up.

Поместите make-файл в тот же каталог, где находится module.c, и выполните команду make . После ее выполнения вы получите файл module.o, который будет находиться в том же каталоге.

# insmod module.o

Вы увидите сообщение My module: Starting... Это же сообщение будет записано в файл протокола /var/log/messages .

Из книги C++ автора Хилл Мюррей

1.1.2 Компиляция Откуда появились выходной поток cout и код, реализующий операцию вывода ««? Для получения выполняемого кода написанная на С++ программа должна быть скомпилирована. По своей сути процесс компиляции такой же, как и для С, и в нем участвует большая часть входящих

Из книги Fedora 8 Руководство пользователя автора

3.4.3. Компиляция Как правило, исходные коды программ распространяются в виде архива с "двойным расширением" -.tar.gz. Исходный код принято распаковывать в каталог /usr/src. Поэтому для распаковки архива вам нужно выполнить следующие команды:sucd /usr/srcgunzip архив.tar.gztar xvf

Из книги Linux для пользователя автора Костромин Виктор Алексеевич

Из книги 200 лучших программ для Linux автора Яремчук Сергей Акимович

17.5.6. Компиляция модулей Если вы сконфигурировали какие-то драйверы как отдельные модули (выбирали при конфигурации вариант "m" при ответе на некоторые вопросы), то вы теперь должны еще выполнить команду make modules, а затем еще команду make modules_install. В файле Documentation/modules.txt можно

Из книги Язык программирования С# 2005 и платформа.NET 2.0. автора Троелсен Эндрю

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

Из книги Asterisk™: будущее телефонии Второе издание автора Меггелен Джим Ван

Условная компиляция Другой пакет директив препроцессора (#if, #elif, #else, #endif) позволяет выполнить компиляцию блока программного кода по условию, базируясь на предварительно заданных символах. Классическим вариантом использования этих директив является идентификация блока

Из книги Сетевые средства Linux автора Смит Родерик В.

Из книги Язык программирования Си для персонального компьютера автора Бочков C. О.

Компиляция libpri Для библиотек libpri не используется программа autoconf для настройки среды сборки или окно выбора компонентов сборки, поскольку они не нужны; таким образом, установка упрощается. libpri применяется различными производителями аппаратных средств

Из книги Linux: Полное руководство автора Колисниченко Денис Николаевич

Компиляция Asterisk После компиляции и установки пакетов zaptel и libpri (если они нужны), можно переходить к установке Asterisk. В этом разделе рассматривается стандартная установка и представлены некоторые альтернативные аргументы make, которые могут

Из книги Linux программирование в примерах автора Роббинс Арнольд

Компиляция ядра После того как вы сконфигурировали ядро системы, выполнив make xconfig или другую команду, приведенную в начале данной главы, вы должны скомпилировать ядро и установить его модули. Для этого необходимо выполнить следующие команды:# make dep# make bzImage# make modules# make

Из книги Язык Си - руководство для начинающих автора Прата Стивен

Условная компиляция В этом разделе описываются директивы, которые управляют условной компиляцией. Эти директивы позволяют исключить из процесса компиляции какие-либо части исходного файла посредством проверки условий (константных

Из книги Linux глазами хакера автора Флёнов Михаил Евгеньевич

20.5. Компиляция ядра 20.5.1. Зачем обновлять ядро? Linux развивается быстрее любой другой операционной системы. Регулярно появляются новые версии ядра, реализующие новые функции. Например, едва успел выйти дистрибутив Fedora Core 4 на ядре 2.6.11, а на www.kernel.org уже лежит стабильная

Из книги Операционная система UNIX автора Робачевский Андрей М.

15.2. Компиляция для отладки Для использования отладчика исходного кода, отлаживаемый исполняемый файл должен быть откомпилирован с опцией компилятора -g. Эта опция заставляет компилятор внедрять в объектный код дополнительные отладочные идентификаторы; то есть

Из книги автора

Почему компиляция? Читатели, пользовавшиеся языком Бейсик, могут удивиться, зачем столько шагов для того, чтобы выполнить программу. Кажется, что такой способ компиляции требует больше времени (и в некоторых случаях это может быть действительно так). Но, поскольку в

Из книги автора

3.8.3. Компиляция ядра При установке из RPM-пакета мы получаем модульное ядро, в котором драйверы устройств могут быть как скомпилированы в одно целое с ядром, так и загружаться отдельно. Такое ядро медленнее в работе, но позволяет обновлять драйверы простой заменой

Из книги автора

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

Зачем вообще самому компилировать ядро?
Пожалуй, главный вопрос, который задают по поводу компиляции ядра: "А зачем мне это делать?".
Многие считают это бессмысленной тратой времени для того, чтобы показать себя умным и продвинутым "линуксоидом". На самом деле компиляция ядра - это очень важное дело. Допустим, вы купили новый ноутбук, в котором у вас не работает веб-камера. Ваши действия? Вы заглядываете в поисковик и ищите решение проблемы по этому вопросу. Довольно часто может оказаться, что ваша веб-камера работает на ядре более новой версии, чем у вас. Если вы не знаете, какая у вас версия - введите в терминале uname -r , в результате вы получите версию ядра (например, linux-2.6.31-10). Также компиляция ядра широко применяется для увеличения производительности: дело в том, что по умолчанию в дистрибутивах ядра компилируются "для всех", из-за этого в нем включено огромное количество драйверов, которые вам могут не понадобиться. Так что если вы хорошо знаете используемое оборудование, то можете отключить ненужные драйвера на этапе конфигурирования. Также есть возможность включить поддержку более 4х Гигабайт оперативной памяти, не меняя разрядность системы. Итак, если вам всё же необходимо иметь своё ядро, приступим к компиляции!

Получение исходного кода ядра.
Первое, что необходимо сделать - получить исходный код нужной версии ядра. Обычно необходимо получить самую новую стабильную версию. Все официальные версии ядра доступны на kernel.org . Если у вас уже установлен X сервер (домашний компьютер), то вы можете перейти на сайт в вашем любимом браузере и скачать нужную версию в архиве tar.gz (сжатый gzip). Если же вы работаете в консоли (например ещё не устанавливали X сервер или конфигурируете сервер), можете воспользоваться текстовым браузером (например elinks). Также можно воспользоваться стандартным менеджером загрузок wget:
wget http://www.kernel.org/pub/linux/kernel/v2.6/linux-2.6.33.1.tar.gz
Но учтите, что вы должны знать точный номер нужной версии.

Распаковка архива исходного кода.
После того как вы получили архив с исходным кодом, вам необходимо распаковать архив в папку. Это можно сделать из графических файловых менеджеров (dolphin,nautilus и т.п) или через mc. Либо воспользуйтесь традиционной командой tar:
tar -zxvf путь_до_архива
Теперь у вас есть папка и исходным кодом, перейдите в неё, используя команду cd каталог_исходного_кода_ядра (чтобы просмотреть список каталогов в папке, используйте команду ls ).

Конфигурация ядра.
После того как вы перешли в каталог с исходным кодом ядра, необходимо выполнить "20 минутную" конфигурацию ядра. Цель её - оставить только нужные драйвера и функции. Все команды уже нужно исполнять от имени суперпользователя.

make config - консольный режим конфигуратора.

make menuconfig - консольный режим в виде списка.

make xconfig - графический режим.

После внесения нужных изменений, сохраните настройки и выйдите из конфигуратора.

Компиляция.
Пришло время завершающего этапа сборки - компиляция. Это делается двумя командами:
make && make install
Первая команда скомпилирует в машинный код все файлы, а вторая установит новое ядро в вашу систему.
Ждем от 20 минут до нескольких часов (в зависимости от мощности компьютера). Ядро установлено. Чтобы оно появилось в списке grub(2), введите (от суперпользователя)
update-grub
Теперь после перезагрузки нажмите "Escape", и вы увидите новое ядро в списке. Если же ядро не включается, то просто загрузитесь со старым ядром и конфигурируйте более аккуратно.

KernelCheck - компиляция ядра не заходя в консоль.
позволяет собрать ядро в полностью графическом режиме для Debian и основанных на нём дистрибутивов . После запуска, KernelCheck предложит свежие версии ядра и патчи, и после вашего согласия, скачает исходных код, запустит графический конфигуратор. Программа соберет ядро в.deb пакеты и установит их. Вам останется лишь перезагрузиться.

Некоторые особенности модульного программирования и общие рекомендации по построению подпрограмм модульной структуры.

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

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

Например, если модули с именами М1,М2 содержат одноименные тип А, переменная В и подпрограмма С, то после подключения этих моделей USES обращения к А, В, С в этой ПЕ будут эквивалентны обращениям к объектам к модулю М2.

Но чтобы характеризовать корректность обращений к нужным одноименным объектам разных подключенных модулей целесообразно при обращении к модулю сначала указывать имя модуля, а через точку имя объекта: М1.А М1.В М1.С М2.В.

Очевидно, что весьма несложно разделить большую программу на две части (ПЕ), т.е. основная программа + модули.

Размещая каждую ПЕ в свой сегмент памяти и в свой дисковый файл.

Все объявления типов, а также тех переменных, которые должны быть доступны отдельным ПЕ (основной программе и будущим модулям) следует поместить в отдельный модуль с пустой исполняемой частью. При этом не следует обращать внимание на то, что какая-то ПЕ (например, модуль) не использует всех этих объявлений. В инициирующей части такого модуля могут быть включены операторы, связывающие файловые переменные с нестандартными текстовыми файлами (ASSIGN) и инициирующие эти файлы, т.е. указывающие для них обращения к передаче данных (RESET и REWRITE).

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

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

В среде ТР имеются средства, управляющие различными способами компиляции модулей.

Compile Alt+F9 RUN Cntr+F9

Destination Memory

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

Режим Compile

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

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

Однако гораздо проще создавать tpu –файлы заодно с компилятором всей программы с помощью других режимов, которые не требуют задания Disk для опции destination.

Режим Make

При компиляции в этом режиме предварительно (до компилирования основной программы) для каждого модуля проверяется:

1) Существования дискового tpu –файла; если его нет, то он создается автоматически путем компилирования исходного текста модуля, т.е. его pas-файл

2) Соответствие найденного tpu –файла исходному тексту модуля, куда могли быть внесены изменения; в противном случае tpu –файл автоматически создается заново

3) Неизменность интерфейсного раздела модуля: если он изменился, то перекомпилируются также все те модули (их исходные pas-файлы), в которых данный модуль указан в предложении USES.

Если изменение в исходных текстах модулей не было, то компилятор работы взаимодействует с этими tpu –файлами и использует время для компиляции.

Режим Build

В отличие от режима Make обязательно требует наличие исходных pas-файлов; проводит компиляцию (перекомпиляцию) каждого модуля и тем самым гарантирует учет всех изменений в текстах pas-файлов. Это увеличивает время компиляции программы в целом.

В отличии от режима сompile режим Make и Build позволяют начинать компилировать программу модульной структуры с любого заданного pas-файла (его и называют первичным) независимо от того, какой файл (или часть программы) находится в активном окне редактора. Для этого в пункте сompile выбирают опцию Primary file нажимают Enter и записывают имя первичного pas-файла и тогда компиляция начнется именно с этого файла.

Если же первичный файл так не указывается, то компиляция в режимах Make, Build и RUN возможно только в том случае, если в активном окне редактора находится основная программа.

Примечание: В будущем, я планирую использовать T2 систему, чтобы компилировать ядро и модули для Puppy. T2 в настоящее время устанавливается, чтобы компилировать ядро и многочисленные дополнительные модули, но не та версия, которая в данный момент используется в Puppy. Я предполагаю синхронизировать в будущих версиях Puppy, таким образом ядро, откомпилированные в T2, будет использоваться в Puppy. См. http://www.puppyos.net/pfs/ для дальнейшей информации относительно Puppy и T2.

У Puppy есть очень простой способ использования C/C++ компиляторов при помощи добавления единственного файла devx_xxx.sfs , где xxx - номер версии. Например, у Puppy 2.12 был бы файл разработки соответствия названный devx_212.sfs . Работая в режиме LiveCD, поместите файл devx_xxx.sfs в то же самое место, где находится ваш персональный файл настроек pup_save.3fs , который, обычно, находится в каталоге /mnt/home/ . Это также относится и для других режимов инсталляции, у которых есть pup_save.3fs файл. Если Puppy установлен на жесткий диск с полной инсталляцией «Option 2», то в этом случае нет никакого личного файла, посмотрите на web-страницах Puppy, чтобы компилирован с различными опциями выбора конфигурации, таким образом модули не совместимы. Эти версии требуют только одного исправления для squashfs . Puppy 2.12 имеет ядро 2.6.18.1 и имеет три исправления; squashfs , значение loglevel в консоли по умолчанию и исправление с выключением компьютера.

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

Первое, что вы должны вначале сделать это скачать само ядро. Оно находится , чтобы найти ссылку на подходящий сайт загрузки. Это должен быть «древний» источник, доступный на kernel.org или его зеркалах.

Подключитесь к интернету, загрузите ядро в папку /usr/src . Затем распакуйте его:

cd / usr/ src tar -jxf linux-2.6.16.7.tar.bz2 tar -zxf linux-2.6.16.7.tar.gz

Вы должны видеть эту папку: /usr/src/linux-2.6.16.7 . Вы тогда должны удостовериться, что эта ссылка указывает на ядро:

ln -sf linux-2.6.16.7 linux ln -sf linux-2.6.16.7 linux-2.6.9

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

Во-вторых, примените исправление Squashfs . Исправление Squashfs добавляет поддержку Squashfs делающую файловую систему только для чтения.

Загрузите исправление, squashfs2.1-patch-k2.6.9.gz , в папку /usr/src . Отметьте,что это исправление было сделано для версии 2.6.9 ядра, но продолжает работать и в 2.6.11.x версиях, пока существует ссылка на linux-2.6.9 . Затем, примените исправление:

Cd/ usr/ src gunzip squashfs2.1-patch-k2.6.9.gz cd/ usr/ src/ linux-2.6.11.11

Замечание, у p1 это число 1, не символ l… (Отличная шутка - прим. перев. )

patch --dry-run -p1 < ../ squashfs2.1-patch patch -p1 < ../ squashfs2.1-patch

Готово! Ядро готово к компилированию!

Компилирование ядра

Необходимо получить файл конфигурации для ядра. Копия его находится в папке /lib/modules .

Затем проделайте эти шаги:

Cd/ usr/ src/ linux-2.6.18.1

Если есть.config файл, скопируйте его куда-нибудь временно или переименуйте.

make clean make mrproper

Скопируйте.config файл для Puppy в /usr/src/linux-2.6.18.1 … В /lib/modules у него будет различные названия, так что переименуйте в.config … Следующие шаги считывают.config файл и генерирует новый.

make menuconfig

… сделайте любые изменения, которые вы хотите и сохраните их. У Вас теперь будет новый.config файл, и Вы должны скопировать его куда-нибудь для сохранности. См. примечание ниже

make bzImage

Вот теперь вы скомпилировали ядро.

Отлично, вы найдете ядро Linux в папке /usr/src/linux-2.6.18.1/arch/i386/boot/bzImage

Компилирование модулей

Теперь войдите в /lib/modules и если уже есть папка, названная 2.6.18.1 , переименуйте папку 2.6.18.1 в 2.6.18.1-old .

Теперь устанавливать новые модули:

Cd/ usr/ src/ linux-2.6.18.1 make modules make modules_install

… после этого вы должны найти новые модули установленными в папке /lib/modules/2.6.18.1 .

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

Как использовать новое ядро и модули

Лучше, если у Вас есть установленный Puppy Unleashed. Тогда tarball расширен и существуют 2 каталога: «boot» и «kernels».

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

У «kernels» каталога есть каталог kernels/2.6.18.1/ , и Вы должны будете заменить модули с Вашими обновленными. Можно и не заменять если Вы перекомпилировали ту же самую версию ядра (2.6.18.1).

Отметьте, что в kernels/2.6.18.1 есть файл c именем "System.map". Вы должны переименовать его и заменить новым из /usr/src/linux-2.6.18.1 . Просмотрите папку kernels/2.6.18.1/ , и Вы должны знать что нужно обновить.

Если Вы компилировали ядро в полной инсталляции Puppy, Вы можете перезагрузить используя новое ядро. make modules_install шагом выше, устанавливали новые модули в /lib/modules/2.6.18.1 , но вы должны также установить новое ядро. Я гружусь с Grub, и просто скопирую новое ядро в каталог /boot (и переименуйте файл с bzImage в vmlinuz).

Примечание, относительно menuconfig (конфигурация меню). Я использовал его целую вечность, так что считайте некоторые вещи само собой разумеющимся, однако новичок мог бы быть сбит с толку, желая выйти от программы. В меню верхнего уровня есть меню, чтобы сохранить конфигурацию - игнорируйте его. Только нажмите TAB клавишу (или клавиша стрелки «вправо»), чтобы подсветить Exit «кнопку» и нажимите клавишу ENTER. После этого вас спросят, хотите ли Вы сохранить новую конфигурацию, и ваш ответ должен быть Да (Yes)