Ring-0

Linux为应用程序提供了强大而广泛的API，但有时这还不够。与一块硬件交互或进行需要访问系统中特权信息的操作需要内核模块。

Linux内核模块是一段编译的二进制代码，它直接插入Linux内核，运行在x86-64处理器中最低且受保护程度最低的Ring0。此处的代码完全未经检查，但以令人难以置信的速度运行，并且可以访问系统中的所有内容。

不仅仅是凡人

编写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`

这将安装本示例所必需的基本开发工具和内核头文件。

下面的示例假设您以普通用户身份运行而不是root用户，但您拥有sudo权限。Sudo是加载内核模块的必需项，但我们希望尽可能在root之外工作。

入门

我们开始编写一些代码。让我们为环境做好准备：

mkdir ~/src/lkm_example
cd ~/src/lkm_example

启动您最喜欢的编辑器（在我的例子中，这是vim）并使用以下内容创建文件lkm_example.c：

#include <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
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);

现在我们已经构建了最简单的模块，让我们举例说明重要的部分：

“includes”包含Linux内核开发所需的头文件。

MODULE_LICENSE可以设置为各种值，具体取决于模块的许可证。要查看完整列表，请运行：

grep “MODULE_LICENSE” -B 27 /usr/src/linux-headers-`uname -r`/include/linux/module.h

我们将init（加载）和exit （卸载）函数定义为static并返回int。

注意使用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

您应该看到以“timestamp”为前缀的“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 <linux/init.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <asm/uaccess.h>
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[MSG_BUFFER_LEN];
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

（在上面的例子中，用你从“make test”或“dmesg”获得的值替换MAJOR）

mknod命令中的“c”告诉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

结论

我希望你喜欢我们通过核心土地的嬉戏。虽然我提供的示例是基本的，但您可以使用此结构构建自己的模块，执行非常复杂的任务。

请记住，你完全依靠自己的核心土地。您的代码没有后备或第二次机会。如果您为客户引用项目，请确保将预期的调试时间加倍（如果不是三倍）。内核代码必须尽可能完美，以确保运行它的系统的完整性和可靠性。

翻译自：https://blog.sourcerer.io/writing-a-simple-linux-kernel-module-d9dc3762c234