Linux 执行写操作时内核中出现空指针异常

我是一名windows驱动程序程序员，也是linux内核开发的完全初学者。我正在尝试简单的linux内核模块

我已经按照下面的代码编写了一个并行端口驱动程序，可以成功地加载这个驱动程序

我使用mknod命令创建了一个char设备节点，其主次编号与代码中的相同。我曾尝试使用cat命令读取该文件，我发现它工作正常。当我尝试使用cat in.txt>/dev/parallel_dev命令编写相同的设备时，提示符显示消息“killed”，在dmesg中，它显示无法处理内核空指针异常

#include<linux/init.h>
#include<linux/module.h>    
#include<linux/kernel.h>    //kprintf
#include<linux/module.h>    //kmalloc
#include<linux/types.h>
#include<linux/fs.h>        //fileoperations,register_chrdev
#include<linux/slab.h>      
#include<linux/uaccess.h>   //copy from/to user 
#include<linux/ioport.h>    //check_region
#include<linux/interrupt.h>
#include<linux/delay.h>

static int parallel_open(struct inode* p_node, struct file* p_file);
static int parallel_release(struct inode* p_node, struct file* p_file);
static ssize_t parallel_read(struct file* p_file, char* buf, size_t count, loff_t* f_pos);
static ssize_t parallel_write(struct file* p_file, const char* buf, size_t count, loff_t* f_pos);
static irqreturn_t parallel_interrupt(int irq,void* dev);

static const int   major_no = 709;
static const char* dev_name = "parallel_tryout";
#define par_base 0x378
int port;
int* parallel_buffer;

struct file_operations fops = {
    .read = parallel_read,
    .write = parallel_write,
    .open = parallel_open,
    .release = parallel_release,
};

static int parallel_init(void)
{
    int reg_result; 

    int irq_req_result;
    unsigned int irq_num = 7;


    printk("Entered init");
    printk("Initializing parallelport dev with major %d",major_no);
    reg_result = register_chrdev(major_no, dev_name, 0);
    if(reg_result < 0 )
    {
        printk("Error registering char dev: %s",dev_name);
    }
    parallel_buffer = kmalloc(16,GFP_KERNEL);
    if(parallel_buffer==NULL)
    {
        printk("Error allocating memory for: %s",dev_name);
    }
    printk("Port registration");
    request_region(0x378,1,"parallelport");
    if(port)
    {
        printk("Error allocating port");
    }
    parallel_buffer = inb(par_base);
    if(parallel_buffer != NULL)
    {
        printk("Allocated buffer");
    }
    irq_req_result = request_irq(irq_num,parallel_interrupt,IRQF_SHARED,dev_name,parallel_buffer);
    return 0;
}
static void parallel_exit(void)
{
    unregister_chrdev(major_no, dev_name);  
    release_region(0x378,1);                
}
static int parallel_open(struct inode* p_node, struct file* p_file)
{
    printk("parallel driver opened from device: %s",dev_name);
    return 0;
}
static int parallel_release(struct inode* p_node, struct file* p_file)
{
    printk("Memory driver closed from device: %s",dev_name);
    return 0;
}
static ssize_t parallel_read(struct file* p_file, char* buf, size_t count, loff_t* f_pos)
{
    copy_to_user(buf,parallel_buffer,1);
    printk("Copied data:%s ",buf);
    printk("Memory driver read from device: %s",dev_name);
    return 0;
}
static ssize_t parallel_write(struct file* p_file, const char* buf, size_t count, loff_t* f_pos)
{

    copy_from_user(parallel_buffer,buf,1);
    printk("Copied data:%s ",parallel_buffer);
    printk("Memory driver written from device: %s",dev_name);

    return 0;
}

static irqreturn_t parallel_interrupt(int irq,void* dev)
{
    irqreturn_t return_value;
    printk("parallel interrupt detected!!!!");
    return return_value;
}
module_init(parallel_init);
module_exit(parallel_exit);

#包括
#包括
#包括//kprintf
#包括//kmalloc
#包括
#包括//文件操作、注册\u chrdev
#包括
#包括//从/向用户复制
#包括//检查区域
#包括
#包括
静态int parallel_open（结构索引节点*p_节点，结构文件*p_文件）；
静态int并行发布（结构索引节点*p_节点，结构文件*p_文件）；
静态ssize_t并行读取（结构文件*p_文件，字符*buf，大小计数，loff_t*f_pos）；
静态ssize_t并行写入（结构文件*p_文件，常量字符*buf，大小计数，loff_t*f_pos）；
静态irqreturn\u t并行中断（int-irq，void*dev）；
主要静态常数=709；
静态常量字符*dev_name=“parallel_tryout”；
#定义par_基准0x378
国际港口；
int*并行缓冲区；
结构文件\u操作fops={
.read=并行读取，
.write=并行写入，
.open=平行_open，
.release=平行释放，
};
静态int并行_init（void）
{
int reg_结果；
int irq_REQU_结果；
无符号整数irq_num=7；
printk（“输入初始值”）；
printk（“使用主%d初始化并行端口开发”，主\u编号）；
reg\U result=寄存器chrdev（主要编号，设备名称，0）；
如果（注册结果<0）
{
printk（“注册字符dev:%s时出错”，dev_name）；
}
并行缓冲区=kmalloc（16，GFP_内核）；
if（并行缓冲区==NULL）
{
printk（“为%s分配内存时出错”，dev_name）；
}
printk（“港口注册”）；
请求_区域（0x378,1，“并行端口”）；
如果（端口）
{
printk（“错误分配端口”）；
}
并行缓冲区=inb（基准）；
if（并行缓冲区！=NULL）
{
printk（“分配的缓冲区”）；
}
irq_req_result=请求_irq（irq_num、并行中断、IRQF_共享、开发名称、并行缓冲区）；
返回0；
}
静态空隙平行_出口（空隙）
{
注销chrdev（专业号、开发名称）；
释放区（0x378,1）；
}
静态int parallel_open（结构索引节点*p_节点，结构文件*p_文件）
{
printk（“从设备%s打开的并行驱动程序”，dev_name）；
返回0；
}
静态int并行发布（结构索引节点*p_节点，结构文件*p_文件）
{
printk（“从设备%s关闭的内存驱动程序”，dev_name）；
返回0；
}
静态ssize\u t并行读取（结构文件*p\u文件，字符*buf，大小计数，loff\u t*f\u位置）
{
复制到用户（buf，并行缓冲区，1）；
printk（“复制的数据：%s”，buf）；
printk（“从设备读取的内存驱动程序：%s”，设备名称）；
返回0；
}
静态ssize_t并行写入（结构文件*p_文件，常量字符*buf，大小计数，loff_t*f_pos）
{
从用户处复制用户（并行缓冲区，buf，1）；
printk（“复制的数据：%s”，并行缓冲区）；
printk（“从设备%s写入的内存驱动程序”，开发人员名称）；
返回0；
}
静态irqreturn\u t并行中断（int-irq，void*dev）
{
irqreturn\u t返回值；
printk（“检测到并行中断！！！！”）；
返回_值；
}
模块_init（并行_init）；
模块出口（平行出口）；

---

这可能是什么原因，请提前感谢。

我不得不问这个问题，但是

ls/dev/parallel\u dev

是否显示了dev？是吗？是的，它显示在/dev/parallel\u dev中，我已将其权限更改为666

static const char*dev\u name=“parallel\u tryout”

为什么？register_chrdev（）需要dev_name right？

printk的
%s
格式说明符需要以null结尾的字符串。