构建一个简单的字符设备，但设备驱动程序文件不会写入或读取
Building a Simple character device but device driver file will not write or read
我正在尝试编写一个简单的字符 device/LKM，它可以读取、写入和查找。
我在这方面遇到了很多问题，但我已经在 it/troubleshooting 上工作了几个星期，但一直无法让它正常工作。目前，我的模块可以正常运行并正确安装和卸载，但是如果我尝试回显设备驱动程序文件，终端就会崩溃，并且当我尝试使用 cat 从它读取时，它 return 被杀死了。
本模块的步骤：
首先，我通过 运行ning make -C /lib/modules/$(uname -r)/build M=$PWD modules
制作模块
对于我的内核，uname -r 是 4.10.17newkernel
我使用 sudo insmod 安装模块 simple_char_driver.ko
如果我运行 lsmod，列出模块
如果我 运行 dmesg，我的初始化函数 "This device is now open" 中的 KERN_ALERT 会正确触发。
此外，如果我 运行 sudo rmmod，该函数 "This device is now closed" KERN_ALERT 也会正确触发。
该模块也正确显示在 cat /proc/devices
我使用 sudo mknod -m 777 /dev/simple_char_driver c 240 0
在 /dev 中创建了设备驱动程序文件
在制作这个文件之前，我确保 240 主号码尚未被使用。
我的设备驱动c文件有如下代码：
#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#define BUFFER_SIZE 1024
MODULE_LICENSE("GPL");
//minor nunmber 0;
static int place_in_buffer = 0;
static int end_of_buffer = 1024;
static int MAJOR_NUMBER = 240;
char* DEVICE_NAME = "simple_char_driver";
typedef struct{
char* buf;
}buffer;
char *device_buffer;
static int closeCounter=0;
static int openCounter=0;
ssize_t simple_char_driver_read (struct file *pfile, char __user *buffer, size_t length, loff_t *offset){
int bytesRead = 0;
if (*offset >=BUFFER_SIZE){
bytesRead = 0;
}
if (*offset + length > BUFFER_SIZE){
length = BUFFER_SIZE - *offset;
}
printk(KERN_INFO "Reading from device\n");
if (copy_to_user(buffer, device_buffer + *offset, length) != 0){
return -EFAULT;
}
copy_to_user(buffer, device_buffer + *offset, length);
*offset += length;
printk(KERN_ALERT "Read: %s", buffer);
printk(KERN_ALERT "%d bytes read\n", bytesRead);
return 0;
}
ssize_t simple_char_driver_write (struct file *pfile, const char __user *buffer, size_t length, loff_t *offset){
int nb_bytes_to_copy;
if (BUFFER_SIZE - 1 -*offset <= length)
{
nb_bytes_to_copy= BUFFER_SIZE - 1 -*offset;
printk("BUFFER_SIZE - 1 -*offset <= length");
}
else if (BUFFER_SIZE - 1 - *offset > length)
{
nb_bytes_to_copy = length;
printk("BUFFER_SIZE - 1 -*offset > length");
}
printk(KERN_INFO "Writing to device\n");
if (*offset + length > BUFFER_SIZE)
{
printk("sorry, can't do that. ");
return -1;
}
printk("about to copy from device");
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
device_buffer[*offset + nb_bytes_to_copy] = '[=10=]';
*offset += nb_bytes_to_copy;
return nb_bytes_to_copy;
}
int simple_char_driver_open (struct inode *pinode, struct file *pfile)
{
printk(KERN_ALERT"This device is now open");
openCounter++;
printk(KERN_ALERT "This device has been opened this many times: %d\n", openCounter);
return 0;
}
int simple_char_driver_close (struct inode *pinode, struct file *pfile)
{
printk(KERN_ALERT"This device is now closed");
closeCounter++;
printk(KERN_ALERT "This device has been closed this many times: %d\n", closeCounter);
return 0;
}
loff_t simple_char_driver_seek (struct file *pfile, loff_t offset, int whence)
{
printk(KERN_ALERT"We are now seeking!");
switch(whence){
case 0:{
if(offset<= end_of_buffer && offset >0){
place_in_buffer = offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;//THIS IS SEEK_SET
}
case 1:{
if(((place_in_buffer+offset)<= end_of_buffer)&&((place_in_buffer+offset)>0)){
place_in_buffer = place_in_buffer+offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;
}
case 2:{//THIS IS SEEK END
if((end_of_buffer-offset)>=0&& offset>0){
place_in_buffer = end_of_buffer-offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;
}
default:{
}
}
printk(KERN_ALERT"I sought %d\n", whence);
return place_in_buffer;
}
struct file_operations simple_char_driver_file_operations = {
.owner = THIS_MODULE,
.read = simple_char_driver_read,
.write = simple_char_driver_write,
.open = simple_char_driver_open,
.llseek = &simple_char_driver_seek,
.release = simple_char_driver_close,
};
static int simple_char_driver_init(void)
{
printk(KERN_ALERT "inside %s function\n",__FUNCTION__);
register_chrdev(MAJOR_NUMBER,DEVICE_NAME, &simple_char_driver_file_operations);
device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
return 0;
}
static void simple_char_driver_exit(void)
{
printk(KERN_ALERT "inside %s function\n",__FUNCTION__);
unregister_chrdev(MAJOR_NUMBER, DEVICE_NAME);
kfree(device_buffer);
}
module_init(simple_char_driver_init);
module_exit(simple_char_driver_exit);
正如我之前所说，此文件生成正确，没有错误或警告。
但是，目前如果我尝试回显到设备文件
使用：echo "hello world" >> /dev/simple_char_driver
我正在使用的终端崩溃
如果我重新打开一个终端，并使用：cat /dev/simple_char_driver
然后终端 return 被杀死。
我完全不知道出了什么问题，我一直在寻找解决方案很长时间都没有成功。如果有人知道出了什么问题，请告诉我。
编辑： 正如下面的用户所建议的，我从读写方法中删除了除 printk 和 return 之外的所有代码，以确保功能被触发。
然后当我使用 echo 时，dmesg 显示 write printk 被触发，并且设备（我已经打开）关闭了。当我随后尝试 cat 设备文件时，dmesg 显示设备重新打开，"ready from device" printk 成功显示，然后设备再次关闭。但是，echo 实际上并没有从设备文件中找到任何可读取的内容，尽管我之前已经将 "Hello world" 回显到其中。
编辑
最终运行的读写函数如下：
ssize_t simple_char_driver_read (struct file *pfile, char __user *buffer, size_t length, loff_t *offset)
{
if (*offset > BUFFER_SIZE)
{
printk("offset is greater than buffer size");
return 0;
}
if (*offset + length > BUFFER_SIZE)
{
length = BUFFER_SIZE - *offset;
}
if (copy_to_user(buffer, device_buffer + *offset, length) != 0)
{
return -EFAULT;
}
*offset += length;
return length;
}
ssize_t simple_char_driver_write (struct file *pfile, const char __user *buffer, size_t length, loff_t *offset){
/* *buffer is the userspace buffer where you are writing the data you want to be written in the device file*/
/* length is the length of the userspace buffer*/
/* current position of the opened file*/
/* copy_from_user function: destination is device_buffer and source is the userspace buffer *buffer */
int nb_bytes_to_copy;
if (BUFFER_SIZE - 1 -*offset <= length)
{
nb_bytes_to_copy= BUFFER_SIZE - 1 -*offset;
printk("BUFFER_SIZE - 1 -*offset <= length");
}
else if (BUFFER_SIZE - 1 - *offset > length)
{
nb_bytes_to_copy = length;
printk("BUFFER_SIZE - 1 -*offset > length");
}
printk(KERN_INFO "Writing to device\n");
if (*offset + length > BUFFER_SIZE)
{
printk("sorry, can't do that. ");
return -1;
}
printk("about to copy from device");
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
device_buffer[*offset + nb_bytes_to_copy] = '[=11=]';
*offset += nb_bytes_to_copy;
return nb_bytes_to_copy;
}
您的代码总体上还有很多不足之处，但目前我能看到的是您的 .write 实现可能有问题。有两个可能的错误 - 缺少缓冲区边界检查和忽略空终止，这可能导致 strlen().
的未定义行为
首先，您知道缓冲区的大小 - BUFFER_SIZE。因此，您应该执行 *offset + length < BUFFER_SIZE 的检查。它应该是 < 而不是 <= 因为无论如何最后一个字节都应该保留用于空终止。因此，如果没有 space 可用（else 分支或 >=），这样的检查应立即使方法 return。我不能确定你是否应该 return 0 报告 什么都没有写 或使用负值来 return 一个错误代码，例如 -ENOBUFS 或 -ENOSPC。无论如何，该方法的 return 值为 ssize_t 意味着负值 可能 为 returned.
其次，如果您的第一次检查成功，您的方法将计算实际可用于写入的 space。即，您可以使用 MIN(A, B) 宏来执行此操作。换句话说，您最好创建一个变量，例如 nb_bytes_to_copy 并像 nb_bytes_to_copy = MIN(BUFFER_SIZE - 1 - *offset, length) 一样初始化它，以便稍后在 copy_from_user() 调用中使用它。例如，如果用户请求从 1021 字节的偏移量开始写入 5 字节的数据，那么您的驱动程序将只允许写入 2 字节的数据 - 比如说，he 而不是 hello。此外，return 值应设置为 nb_bytes_to_copy，以便调用者能够检测到缓冲区 space 不足。
最后，不要忘记空终止。一旦你完成
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
你要注意做一些像
device_buffer[*offset + nb_bytes_copy] = '[=11=]';
或者，如果我没记错的话，您可以使用像 strncopy_from_user() 这样的特殊函数来确保复制数据时带有隐式空终止符。
此外，尽管空终止写入不会导致后续 strlen() 出现问题，但我怀疑您是否需要它。你可以简单地做 *offset += nb_bytes_to_copy.
顺便说一下，我建议以更具描述性的方式命名 arguments/variables。 *offset 很碍眼。如果命名为 *offsetp 会更好看。如果你的方法变得很大，平均 reader 将不太可能记住 offset 是一个指针而不是一个值。 offsetp 其中 p 代表 "pointer" 将减轻将来支持您的代码的任何人的工作。
综上所述，我怀疑您的 .write 实现并建议您重新设计。如果其他一些错误仍然存在，您将需要进一步调试它们。添加调试打印输出可能会派上用场，但请先重新审视基本要点，例如空终止和缓冲区边界保护。为了使我的回答对您更有用，我在 "Linux Device Drivers 3" 书中的 section 3.7 中提供了 link，这将阐明正在讨论的主题。
我正在尝试编写一个简单的字符 device/LKM，它可以读取、写入和查找。 我在这方面遇到了很多问题，但我已经在 it/troubleshooting 上工作了几个星期，但一直无法让它正常工作。目前，我的模块可以正常运行并正确安装和卸载，但是如果我尝试回显设备驱动程序文件，终端就会崩溃，并且当我尝试使用 cat 从它读取时，它 return 被杀死了。
本模块的步骤：
首先，我通过 运行ning make -C /lib/modules/$(uname -r)/build M=$PWD modules
制作模块对于我的内核，uname -r 是 4.10.17newkernel
我使用 sudo insmod 安装模块 simple_char_driver.ko
如果我运行 lsmod，列出模块
如果我 运行 dmesg，我的初始化函数 "This device is now open" 中的 KERN_ALERT 会正确触发。
此外，如果我 运行 sudo rmmod，该函数 "This device is now closed" KERN_ALERT 也会正确触发。
该模块也正确显示在 cat /proc/devices
我使用 sudo mknod -m 777 /dev/simple_char_driver c 240 0
在 /dev 中创建了设备驱动程序文件在制作这个文件之前，我确保 240 主号码尚未被使用。
我的设备驱动c文件有如下代码：
#include<linux/init.h>
#include<linux/module.h>
#include<linux/fs.h>
#include<linux/slab.h>
#include<asm/uaccess.h>
#define BUFFER_SIZE 1024
MODULE_LICENSE("GPL");
//minor nunmber 0;
static int place_in_buffer = 0;
static int end_of_buffer = 1024;
static int MAJOR_NUMBER = 240;
char* DEVICE_NAME = "simple_char_driver";
typedef struct{
char* buf;
}buffer;
char *device_buffer;
static int closeCounter=0;
static int openCounter=0;
ssize_t simple_char_driver_read (struct file *pfile, char __user *buffer, size_t length, loff_t *offset){
int bytesRead = 0;
if (*offset >=BUFFER_SIZE){
bytesRead = 0;
}
if (*offset + length > BUFFER_SIZE){
length = BUFFER_SIZE - *offset;
}
printk(KERN_INFO "Reading from device\n");
if (copy_to_user(buffer, device_buffer + *offset, length) != 0){
return -EFAULT;
}
copy_to_user(buffer, device_buffer + *offset, length);
*offset += length;
printk(KERN_ALERT "Read: %s", buffer);
printk(KERN_ALERT "%d bytes read\n", bytesRead);
return 0;
}
ssize_t simple_char_driver_write (struct file *pfile, const char __user *buffer, size_t length, loff_t *offset){
int nb_bytes_to_copy;
if (BUFFER_SIZE - 1 -*offset <= length)
{
nb_bytes_to_copy= BUFFER_SIZE - 1 -*offset;
printk("BUFFER_SIZE - 1 -*offset <= length");
}
else if (BUFFER_SIZE - 1 - *offset > length)
{
nb_bytes_to_copy = length;
printk("BUFFER_SIZE - 1 -*offset > length");
}
printk(KERN_INFO "Writing to device\n");
if (*offset + length > BUFFER_SIZE)
{
printk("sorry, can't do that. ");
return -1;
}
printk("about to copy from device");
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
device_buffer[*offset + nb_bytes_to_copy] = '[=10=]';
*offset += nb_bytes_to_copy;
return nb_bytes_to_copy;
}
int simple_char_driver_open (struct inode *pinode, struct file *pfile)
{
printk(KERN_ALERT"This device is now open");
openCounter++;
printk(KERN_ALERT "This device has been opened this many times: %d\n", openCounter);
return 0;
}
int simple_char_driver_close (struct inode *pinode, struct file *pfile)
{
printk(KERN_ALERT"This device is now closed");
closeCounter++;
printk(KERN_ALERT "This device has been closed this many times: %d\n", closeCounter);
return 0;
}
loff_t simple_char_driver_seek (struct file *pfile, loff_t offset, int whence)
{
printk(KERN_ALERT"We are now seeking!");
switch(whence){
case 0:{
if(offset<= end_of_buffer && offset >0){
place_in_buffer = offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;//THIS IS SEEK_SET
}
case 1:{
if(((place_in_buffer+offset)<= end_of_buffer)&&((place_in_buffer+offset)>0)){
place_in_buffer = place_in_buffer+offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;
}
case 2:{//THIS IS SEEK END
if((end_of_buffer-offset)>=0&& offset>0){
place_in_buffer = end_of_buffer-offset;
printk(KERN_ALERT" this is where we are in the buffer: %d\n", place_in_buffer);
}
else{
printk(KERN_ALERT"ERROR you are attempting to go ouside the Buffer");
}
break;
}
default:{
}
}
printk(KERN_ALERT"I sought %d\n", whence);
return place_in_buffer;
}
struct file_operations simple_char_driver_file_operations = {
.owner = THIS_MODULE,
.read = simple_char_driver_read,
.write = simple_char_driver_write,
.open = simple_char_driver_open,
.llseek = &simple_char_driver_seek,
.release = simple_char_driver_close,
};
static int simple_char_driver_init(void)
{
printk(KERN_ALERT "inside %s function\n",__FUNCTION__);
register_chrdev(MAJOR_NUMBER,DEVICE_NAME, &simple_char_driver_file_operations);
device_buffer = kmalloc(BUFFER_SIZE, GFP_KERNEL);
return 0;
}
static void simple_char_driver_exit(void)
{
printk(KERN_ALERT "inside %s function\n",__FUNCTION__);
unregister_chrdev(MAJOR_NUMBER, DEVICE_NAME);
kfree(device_buffer);
}
module_init(simple_char_driver_init);
module_exit(simple_char_driver_exit);
正如我之前所说，此文件生成正确，没有错误或警告。 但是，目前如果我尝试回显到设备文件
使用：echo "hello world" >> /dev/simple_char_driver
我正在使用的终端崩溃
如果我重新打开一个终端，并使用：cat /dev/simple_char_driver
然后终端 return 被杀死。
我完全不知道出了什么问题，我一直在寻找解决方案很长时间都没有成功。如果有人知道出了什么问题，请告诉我。
编辑： 正如下面的用户所建议的，我从读写方法中删除了除 printk 和 return 之外的所有代码，以确保功能被触发。 然后当我使用 echo 时，dmesg 显示 write printk 被触发，并且设备（我已经打开）关闭了。当我随后尝试 cat 设备文件时，dmesg 显示设备重新打开，"ready from device" printk 成功显示，然后设备再次关闭。但是，echo 实际上并没有从设备文件中找到任何可读取的内容，尽管我之前已经将 "Hello world" 回显到其中。
编辑
最终运行的读写函数如下：
ssize_t simple_char_driver_read (struct file *pfile, char __user *buffer, size_t length, loff_t *offset)
{
if (*offset > BUFFER_SIZE)
{
printk("offset is greater than buffer size");
return 0;
}
if (*offset + length > BUFFER_SIZE)
{
length = BUFFER_SIZE - *offset;
}
if (copy_to_user(buffer, device_buffer + *offset, length) != 0)
{
return -EFAULT;
}
*offset += length;
return length;
}
ssize_t simple_char_driver_write (struct file *pfile, const char __user *buffer, size_t length, loff_t *offset){
/* *buffer is the userspace buffer where you are writing the data you want to be written in the device file*/
/* length is the length of the userspace buffer*/
/* current position of the opened file*/
/* copy_from_user function: destination is device_buffer and source is the userspace buffer *buffer */
int nb_bytes_to_copy;
if (BUFFER_SIZE - 1 -*offset <= length)
{
nb_bytes_to_copy= BUFFER_SIZE - 1 -*offset;
printk("BUFFER_SIZE - 1 -*offset <= length");
}
else if (BUFFER_SIZE - 1 - *offset > length)
{
nb_bytes_to_copy = length;
printk("BUFFER_SIZE - 1 -*offset > length");
}
printk(KERN_INFO "Writing to device\n");
if (*offset + length > BUFFER_SIZE)
{
printk("sorry, can't do that. ");
return -1;
}
printk("about to copy from device");
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
device_buffer[*offset + nb_bytes_to_copy] = '[=11=]';
*offset += nb_bytes_to_copy;
return nb_bytes_to_copy;
}
您的代码总体上还有很多不足之处，但目前我能看到的是您的 .write 实现可能有问题。有两个可能的错误 - 缺少缓冲区边界检查和忽略空终止，这可能导致 strlen().
首先，您知道缓冲区的大小 - BUFFER_SIZE。因此，您应该执行 *offset + length < BUFFER_SIZE 的检查。它应该是 < 而不是 <= 因为无论如何最后一个字节都应该保留用于空终止。因此，如果没有 space 可用（else 分支或 >=），这样的检查应立即使方法 return。我不能确定你是否应该 return 0 报告 什么都没有写 或使用负值来 return 一个错误代码，例如 -ENOBUFS 或 -ENOSPC。无论如何，该方法的 return 值为 ssize_t 意味着负值 可能 为 returned.
其次，如果您的第一次检查成功，您的方法将计算实际可用于写入的 space。即，您可以使用 MIN(A, B) 宏来执行此操作。换句话说，您最好创建一个变量，例如 nb_bytes_to_copy 并像 nb_bytes_to_copy = MIN(BUFFER_SIZE - 1 - *offset, length) 一样初始化它，以便稍后在 copy_from_user() 调用中使用它。例如，如果用户请求从 1021 字节的偏移量开始写入 5 字节的数据，那么您的驱动程序将只允许写入 2 字节的数据 - 比如说，he 而不是 hello。此外，return 值应设置为 nb_bytes_to_copy，以便调用者能够检测到缓冲区 space 不足。
最后，不要忘记空终止。一旦你完成
copy_from_user(device_buffer + *offset, buffer, nb_bytes_to_copy);
你要注意做一些像
device_buffer[*offset + nb_bytes_copy] = '[=11=]';
或者，如果我没记错的话，您可以使用像 strncopy_from_user() 这样的特殊函数来确保复制数据时带有隐式空终止符。
此外，尽管空终止写入不会导致后续 strlen() 出现问题，但我怀疑您是否需要它。你可以简单地做 *offset += nb_bytes_to_copy.
顺便说一下，我建议以更具描述性的方式命名 arguments/variables。 *offset 很碍眼。如果命名为 *offsetp 会更好看。如果你的方法变得很大，平均 reader 将不太可能记住 offset 是一个指针而不是一个值。 offsetp 其中 p 代表 "pointer" 将减轻将来支持您的代码的任何人的工作。
综上所述，我怀疑您的 .write 实现并建议您重新设计。如果其他一些错误仍然存在，您将需要进一步调试它们。添加调试打印输出可能会派上用场，但请先重新审视基本要点，例如空终止和缓冲区边界保护。为了使我的回答对您更有用，我在 "Linux Device Drivers 3" 书中的 section 3.7 中提供了 link，这将阐明正在讨论的主题。