[Перевод] Управляем модулем ядра Linux
Почему пользовательское приложение работает некорректно? Существует не так много способов, которые бы помогали выявить проблему. В большинстве случаев для поддержания высокой доступности требуется стороннее программное обеспечение. В статье рассказываем, как настроить мониторинг пользовательского приложения через модуль ядра Linux, а также разбираем, как установить связь с сокетом.
Введение
Двустороннее взаимодействие между пользовательским приложением и модулем ядра:
Application: любое приложение, запущенное на уровне пользователя, которое может взаимодействовать с модулем ядра.
Kernel Module: содержит определение системных вызовов, которые могут использоваться API-интерфейсами приложений и ядра для мониторинга работоспособности.
«Администрирование Linux. Мега»
Проверка состояния модуля ядра
Разберём команды, которые полезны при написании и использовании расширений ядра.
Загрузка модуля ядра
insmod: используется для вставки модуля в ядро.
пример: insmod «kernel_ext_binary»
# insmod helloWorld.ko
Welcome to Hello world Module.Выгрузка модуля ядра
пример: rmmod «kernel_ext_binary»
# rmmod helloWorld.ko
Goodbye, from Hello world.Список всех запущенных модулей ядра
lsmod: выводит список всех загруженных модулей ядра.
пример: lsmod | grep «kernel_ext_binary»
# lsmod | grep hello
helloWorld 12189 1Подробная информация о модуле ядра
modinfo: отображает дополнительную информацию о модуле.
пример: modinfo hello*.ko
# modinfo helloWorld.ko
filename: /root/helloWorld.ko
description: Basic Hello World KE
author: helloWorld
license: GPL
rhelversion: 7.3
srcversion: 5F60F86F84D8477986C3A50
depends:
vermagic: 3.10.0-514.el7.ppc64le SMP mod_unload modversionsПеречисленные команды можно запускать на консоли и через бинарное приложение с помощью вызова system().
Связь с пользовательским пространством
Пользовательское пространство должно открыть файл по указанному пути с помощью open () API. Этот файл используется пользовательским приложением и модулем ядра для взаимодействия друг с другом. Все команды и данные из пользовательского приложения записываются в этот файл, из которого модуль ядра считывает и выполняет действия. Возможно и обратное.
#include
#include
#include
int open(const char *pathname, int flags); Пример:
int fd;
#define DEVICE_FILE_NAME "/dev/char_dev"
fd = open(DEVICE_FILE_NAME, 0);Возвращаемое значениеopen() — дескриптор файла, небольшое неотрицательное целое число, которое используется в последующих системных вызовах (в данном случае ioctl).
Использование вызовов ioctl
Системный вызов ioctl() может быть вызван из пользовательского пространства для управления базовыми параметрами устройства.
#include
int ioctl(int fd, int cmd, ...); fd — это файловый дескриптор, возвращаемый из open(), а cmd — то же самое, что реализовано в ioctl() модуля ядра.
Пример:
#define IOCTL_SEND_MSG _IOR(MAJOR_NUM, 0, char *)
int ret_val;
char message[100];
ret_val = ioctl(file_desc, IOCTL_SEND_MSG, message);
if (ret_val < 0) {
printf("ioctl_send_msg failed:%d\n", ret_val);
exit(−1);
}В приведенном примере IOCTL_SEND_MSG — команда, которая отправляется модулю.
_IOR означает, что приложение создаёт номер команды ioctl для передачи информации из пользовательского приложения в модуль ядра.
Первый аргумент, MAJOR_NUM, — основной номер используемого нами устройства.
Второй аргумент — номер команды (их может быть несколько с разным значением).
Третий аргумент — тип, который мы хотим передать от процесса к ядру.
Точно так же пользовательское приложение может получить сообщение от ядра с небольшим изменением аргументов ioctl.
Обработка потоков в модуле ядра
В следующих разделах рассмотрим способы обработки многопоточности в контексте ядра.
Создание потока
Мы можем создать несколько потоков в модуле, используя следующие вызовы:
#include
static struct task_struct * sampleThread = NULL;
sampleThread = kthread_run(threadfn, data, namefmt, …) kthread_run() создаёт новый поток и сообщает ему о запуске.
threadfn — имя функции для запуска.
data * — указатель на аргументы функции.
namefmt — имя потока (в выводе команды ps)
Остановка потока
Мы можем остановить запущенные потоки, используя вызов:
kthread_stop(sampleThread)
Установка связи с сокетом
Можно создать необработанный сокет с помощью функции sock_create(). Через этот сокет модуль ядра будет взаимодействовать с другими приложениями пользовательского уровня внутри или вне хоста.
struct socket *sock;
struct sockaddr_ll *s1 = kmalloc(sizeof(struct sockaddr_ll),GFP_KERNEL);
result = sock_create(PF_PACKET, SOCK_RAW, htons(ETH_P_IP), &sock);
if(result < 0)
{
printk(KERN_INFO "[vmmKE] unable to create socket");
return -1;
}
//copy the interface name to ifr.name and other required information.
strcpy((char *)ifr.ifr_name, InfName);
s1->sll_family = AF_PACKET;
s1->sll_ifindex = ifindex;
s1->sll_halen = ETH_ALEN;
s1->sll_protocol = htons(ETH_P_IP);
result = sock->ops->bind(sock, (struct sockaddr *)s1, sizeof(struct sockaddr_ll));
if(result < 0)
{
printk(KERN_INFO "[vmmKE] unable to bind socket");
return -1;
}С помощью sock_sendmsg() модуль ядра может отправлять данные, используя структуру сообщения.
struct msghdr message;
int ret= sock_sendmsg(sock, (struct msghdr *)&message);Генерация сигналов процессу пользовательского пространства
Сигналы тоже можно сгенерировать из модуля ядра в пользовательское приложение. Если идентификатор процесса (PID) известен ядру, используя этот pid, модуль может заполнить требуемую структуру pid и передать ее в send_sig_info() для запуска сигнала.
struct pid *pid_struct = find_get_pid(pid);
struct task_struct *task = pid_task(pid_struct,PIDTYPE_PID);
int signum = SIGKILL, sig_ret;
struct siginfo info;
memset(&info, '\0', sizeof(struct siginfo));
info.si_signo = signum;
//send a SIGKILL to the daemon
sig_ret = send_sig_info(signum, &info, task);
if (sig_ret < 0)
{
printk(KERN_INFO "error sending signal\n");
return -1;
}Ротация логов
Если пользователь хочет перенаправить все логи, связанные с модулем ядра, в определённый файл, необходимо добавить запись в rsyslog (/etc/rsyslog.conf) следующим образом:
:msg,startswith,"[HelloModule]" /var/log/helloModule.log
Это позволяет rsyslog перенаправлять все логи ядра, начинающиеся с [Hello Module], в модуль /var/log/helloModule.log file.
Пример: пользователи могут написать собственный сценарий ротации и поместить его в /etc/logrotate.d.
"/var/log/helloModule.log" {
daily
rotate 4
maxsize 2M
create 0600 root
postrotate
service rsyslog restart > /dev/null
endscript
}Сценарий ежедневно проверяет, не превышает ли размер файла логов 2 МБ, и поддерживает 4 ротации этого файла. Если размер логов превышает 2 МБ, будет создан новый файл с тем же именем и правами доступа к файлу 0600, а к старому файлу будет добавлена отметка даты и времени.
После ротации он перезапустит службу rsyslog.
Создание файла
Обратитесь к содержимому makefile, чтобы сгенерировать двоичные файлы для сэмпла программы:
obj−m += helloWorld.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Примечание: пример основан на варианте RHEL. Другие варианты реализации makefile могут отличаться.
Интеграция модуля ядра с пользовательским приложением
Пользовательское приложение использует вызовы ioctl для отправки данных в модуль ядра. В приведённом ниже примере эти вызовы ioctl можно использовать для отправки сведений о приложении или отправки обновлений в более поздний момент времени.
Пример пользовательского приложения
Пример включает в себя все концепции, описанные ранее.
# cat helloWorld.h
#ifndef HELLOWORLD_H
#define HELLOWORLD_H
#include
// cmd ‘KE_DATA_VAR’ to send the integer type data
#define KE_DATA_VAR _IOR('q', 1, int *)
#endif
# cat helloWorld.c
#include
#include
#include
#include
#include
#include
#include
#include "helloWorld.h"
/* @brief: function to load the kernel module */
void load_KE()
{
printf ("loading KE\n");
if (system ("insmod /root/helloWorld.ko") == 0)
{
printf ("KE loaded successfully");
}
}
/* @brief: function to unload the kernel module */
void unload_KE()
{
printf ("unloading KE\n");
if (system ("rmmod /root/helloWorld.ko") == 0)
{
printf ("KE unloaded successfully");
}
}
/* @brief: method to send data to kernel module */
void send_data(int fd)
{
int v;
printf("Enter value: ");
scanf("%d", &v);
getchar();
if (ioctl(fd, KE_DATA_VAR, &v) == -1)
{
perror("send data error at ioctl");
}
}
int main(int argc, char *argv[])
{
const char *file_name = "/dev/char_device"; //used by ioctl
int fd;
enum
{
e_load, //load the kernel module
e_unload, //unload the kernel module
e_send, //send a HB from test binary to kernel module
} option;
if (argc == 2)
{
if (strcmp(argv[1], "-l") == 0)
{
option = e_load;
}
else if (strcmp(argv[1], "-u") == 0)
{
option = e_unload;
}
}
else if (strcmp(argv[1], "-s") == 0)
{
option = e_send;
}
else
{
fprintf(stderr, "Usage: %s [-l | -u | -s ]\n", argv[0]);
return 1;
}
}
else
{
fprintf(stderr, "Usage: %s [-l | -u | -s ]\n", argv[0]);
return 1;
}
if ((option != e_load) && (option != e_unload))
{
fd = open(file_name, O_RDWR);
if (fd == -1)
{
perror("KE ioctl file open");
return 2;
}
}
switch (option)
{
case e_load:
load_KE();
break;
case e_unload:
unload_KE();
break;
case e_send:
send_data(fd);
break;
default:
break;
}
if ((option != e_load) && (option != e_unload))
{
close (fd);
}
return 0;
}
Sample kernel module
# cat helloWorld.c
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
typedef struct
{
char ethInfName[8];
char srcMacAdr[15];
char destMacAdr[15];
int ifindex;
}KEConfig_t;
MODULE_LICENSE("GPL");
MODULE_AUTHOR("Owner Name");
MODULE_DESCRIPTION("Sample Hello world");
MODULE_VERSION("0.1");
static char *name = "world";
static struct task_struct *ke_thread;
static struct KEConfig_t KECfg;
module_param(name, charp, S_IRUGO);
MODULE_PARM_DESC(name, "The name to display in /var/log/kern.log");
/* @brief: create socket and send required data to HM
* creates the socket and binds on to it.
* This method will also send event notification
* to HM.
* */
static int createSocketandSendData(char *data)
{
int ret_l =0;
mm_segment_t oldfs;
struct msghdr message;
struct iovec ioVector;
int result;
struct ifreq ifr;
struct socket *sock;
struct sockaddr_ll *s1 = kmalloc(sizeof(struct sockaddr_ll),GFP_KERNEL);
if (!s1)
{
printk(KERN_INFO "failed to allocate memory");
return -1;
}
printk(KERN_INFO "inside configureSocket");
memset(s1, '\0', sizeof(struct sockaddr_ll));
memset(픦, '\0', sizeof(ifr));
result = sock_create(PF_PACKET, SOCK_RAW, htons(ETH_P_IP), &sock);
if(result < 0)
{
printk(KERN_INFO "unable to create socket");
return -1;
}
printk(KERN_INFO "interface: %s", KECfg.ethInfName);
printk(KERN_INFO "ifr index: %d", KECfg.ifindex);
strcpy((char *)ifr.ifr_name, KECfg.ethInfName);
s1->sll_family = AF_PACKET;
s1->sll_ifindex = KECfg.ifindex;
s1->sll_halen = ETH_ALEN;
s1->sll_protocol = htons(ETH_P_IP);
result = sock->ops->bind(sock, (struct sockaddr *)s1, sizeof(struct sockaddr_ll));
if(result < 0)
{
printk(KERN_INFO "Unable to bind socket");
return -1;
}
//create the message header
memset(&message, 0, sizeof(message));
message.msg_name = sockData->sock_ll;
message.msg_namelen = sizeof(*(sock_ll));
ioVector.iov_base = data;
ioVector.iov_len = sizeof(data);
message.msg_iov = &ioVector;
message.msg_iovlen = 1;
message.msg_control = NULL;
message.msg_controllen = 0;
oldfs = get_fs();
set_fs(KERNEL_DS);
ret_l = sock_sendmsg(sockData->sock, &message, sizeof(data));
return 0;
}
static long ke_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
{
int b;
switch (cmd)
{
case KE_DATA_VAR:
if (get_user(b, (int *)arg))
{
return -EACCES;
}
//set the time of HB here
mutex_lock(&dataLock);
do_gettimeofday(&hbTv);
printk(KERN_INFO "time of day is %ld:%lu \n", hbTv.tv_sec, hbTv.tv_usec);
printk(KERN_INFO "data %d\n", b);
//send data out
createSocketandSendData(&b);
mutex_unlock(&dataLock);
break;
default:
return -EINVAL;
}
return 0;
}
/* @brief: method to register the ioctl call */
static struct file_operations ke_fops =
{
.owner = THIS_MODULE,
#if (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,35))
.ioctl = ke_ioctl
#else
.unlocked_ioctl = ke_ioctl
#endif
};
/* @brief The thread function */
int ke_init()
{
printk(KERN_INFO "Inside function");
return 0;
}
/* @brief The LKM initialization function */
static int __init module_init(void)
{
printk(KERN_INFO "module_init initialized\n");
if ((ret = alloc_chrdev_region(&dev, FIRST_MINOR, MINOR_CNT, "KE_ioctl")) < 0)
{
return ret;
}
cdev_init(&c_dev, &ke_fops);
if ((ret = cdev_add(&c_dev, dev, MINOR_CNT)) < 0)
{
return ret;
}
if (IS_ERR(cl = class_create(THIS_MODULE, "char")))
{
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
return PTR_ERR(cl);
}
if (IS_ERR(dev_ret = device_create(cl, NULL, dev, NULL, "KEDevice")))
{
class_destroy(cl);
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
return PTR_ERR(dev_ret);
}
//create related threads
mutex_init(&dataLock); //initialize the lock
KEThread = kthread_run(ke_init,"KE thread","KEThread");
return 0;
}
void thread_cleanup(void)
{
int ret = 0;
if (ke_thread)
ret = kthread_stop(ke_thread);
if (!ret)
printk(KERN_INFO "Kernel thread stopped");
}
/* @brief The LKM cleanup function */
static void __exit module_exit(void)
{
device_destroy(cl, dev);
class_destroy(cl);
cdev_del(&c_dev);
unregister_chrdev_region(dev, MINOR_CNT);
thread_cleanup();
printk(KERN_INFO "Exit %s from the Hello world!\n", name);
}
module_init(module_init);
module_exit(module_exit); Модуль всегда начинается либо сinit_module, либо с функции, которую вы указываете с помощью вызова module_init(). Эта функция сообщает ядру, какие функциональные возможности предоставляет модуль, и настраивает ядро для запуска функций модуля, когда они необходимы.
Все модули заканчиваются вызовом либоcleanup_module(), либо функции, которую вы указываете с помощью вызова module_exit(). Это функция выхода для модулей — она отменяет всё, что сделала функция ввода.
Примечание: предположим, файл открыт в пользовательском пространстве с помощью функцииopen(), которая используется для связи с модулем ядра.
Если какой-либо вызов execve() выполняется пользовательским процессом, нужно установить параметр сокета FD_CLOEXEC в fd (файловый дескриптор).
fd = open("/dev/char_device”, O_RDWR);
fcntl(fd, F_SETFD, FD_CLOEXEC);Если параметр FD_CLOEXEC не установлен для этого fd, дескриптор файла должен оставаться открытым при вызове execve().
Коротко о главном
В статье рассмотрели способы мониторинга пользовательских приложений и их перезапуска в случае сбоя или зависания. А также разобрали способы ротации логов ядра и установления связи сокета второго уровня с пользовательскими приложениями.
«Администрирование Linux. Мега»
