基于Linux的驱动开发：内核模块传参、内核到处符号表、字符设备驱动

已于 2023-10-21 09:24:14 修改
阅读量656 收藏 1
点赞数
文章标签： Linux驱动 学习
于 2023-10-21 01:10:42 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46766479/article/details/133954861
版权

内核模块传参

        内核模块：

                int a , b;

        安装内核模块时：insmod demo.ko a = 100 b =10;

1.内核模块传参的意义

        在安装内核模块时给内核模块中的变量进行数值传递，这样可以让我们的内核模块向上兼容更为复杂的应用程序，向下适配多种硬件

2.内核模块传参相关API

        1.函数原型：module_param(name, type, perm)

        功能： 声明可以进行内核模块传参的变量

        参数：name : 变量名

                   type：要传参的数值类型---》byte(传递char), hexint(16进制的int)、short 、int、uint、long、ulong、charp(传递字符指针)、bool(0/1 y/n Y/N) 

                   perm：文件权限，通过module_param声明了要传参的变量，那么在sys/module/当前模块/parameters/下会生成一个以当前变量为名的文件，文件的权限为perm指定的权限，文件内容为变量的值

        注：通过modinfo查看您当前内核模块可以进行命令行传参的变量有哪些

        2.函数原型：MODULE_PARM_DESC(_parm, desc)

        功能：添加要传参的变量的描述，这个描述也可以通过modinfo查看

        参数：_parm :传参的变量名

                  desc：添加的描述

        注：给char类型的变量传参时，需要传递对应的ASCII十进制形式

                给字符指针传递字符串时，字符串不可以有空格，若有空格，空格前的被当作参数传递给变量，后面的会被认为时一个不认识的变量

示例代码 

内核导出符号表

 

1.导出符号表的意义

        导出符号表可以让不同模块之间实现资源的相互访问 ，比如模块2想要访问模块1的资源，只需将模块1资源的符号表导出给模块2，此时，模块2就可以访问模块1的资源了

2.导出符号表的相关API

EXPORT_SYMBOL(变量名|函数名)

或者

EXPORT_SYMBOL_CPL(变量名|函数名)

3.导出符号表测试实例

3.1编写代码

定义demo1.c,完成函数的定义

#include <linux/init.h>
#include <linux/module.h>
int add(int i,int j)
{
    return i+j;
}
//生成add的符号表文件
EXPORT_SYMBOL(add);
static int __init mycdev_init(void)
{
    
    return 0;
}
static void __exit mycdev_exit(void)
{


}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

 定义dem2.c,完成调用demo1.c中的函数

#include <linux/init.h>
#include <linux/module.h>

extern int add(int i,int j);
static int __init mycdev_init(void)
{
    printk("调用模块1函数执行结果为：%d",add(3,5));
    return 0;
}
static void __exit mycdev_exit(void)
{


}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

3.2编译

先编译demo1.c将生成的符号表文件Module.symvers复制到demo2的路径下再编译demo2.c

此时通过modinifo查看demo2.ko，显示demo2依赖于demo1

注意 ：在高版本的内核中不支持符号表文件直接复制，不然编译报未定义错误

解决办法：在demo2的Makefile中加上demo1符号表的文件路径3.3安装流程

先安装demo1，再安装demo2

3.4卸载

先卸载demo2,再卸载demo1

字符设备驱动

1.字符设备驱动的定义

字符设备是以字节流的形式进行顺序访问的设备，针对字节设备设计的驱动框架叫做字符设备驱动。当前市面上绝大多数的设备都属于字符设备，比如键盘、鼠标、摄像头...

2.字符设备驱动的框架

1.当在内核中注册一个字符设备驱动后会得到驱动对应的设备号，设备号是设备的唯一标识。设备号分为主设备号和次设备号，主设备号（高12位）：用来标识一类设备 ，此设备号（低20位）：用来标识这一类中的某一个设备。设备号=主设备号<<20 | 次设备号

2.根据设备号可以通过某种方式在文件系统中创建设备文件，相当于通过设备号将设备文件和驱动绑定

3.当设备文件被创建后，应用程序中调用 open() | read() | write() | close()

4.调用以上函数时，驱动中对应的操作应用方法会被回调

5.在驱动的操作方法中完成硬件的控制

3.字符设备驱动的注册和注销

3.1相关API 

头文件：#include <linux/fs.h>

注册字符设备驱动

int register_chrdev(unsigned int major, const char *name, const struct file_operations *fops)

功能：实现字符设备驱动的注册，一次申请256个设备的资源（0-255个此设备号）

参数：major：主设备号

                >0 静态指定主设备号

                =0 动态申请主设备号

           name：注册得到的驱动名字

           fops：操作方法结构体指针，指向操作方法结构体变量

返回值：

        失败返回错误码

        成功：若major>0，则返回申请得到主设备号

                   若major=0，则返回0

操作方法结构体，用于保存和管理驱动的各自操作方法

struct file_operations {

        int (*open) (struct inode *, struct file *);

        ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);

        ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);

        int (*release) (struct inode *, struct file *);

};

注销字符设备驱动

void unregister_chrdev(unsigned int major, const char *name)

功能：实现字符设备驱动的注销

参数：major：驱动对应的主设备号

           name：注册时填写的驱动号

返回值：无

3.2字符设备驱动注册实例

1.编写代码

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
unsigned int major;
// 封装操作方法，这些操作方法在应用层进行系统调用时被回调
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
// 定义操作方法结构体对象，保存封装的操作方法
struct file_operations fops = {
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
};
//入口函数
static int __init mycdev_init(void)
{
    // 注册字符设备驱动
    major = register_chrdev(0, "mychrdev", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("注册字符设备驱动成功major=%d\n", major);
    return 0;
}
//出口函数
static void __exit mycdev_exit(void)
{
    //注销字符设备驱动
    unregister_chrdev(major,"mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

2.编译驱动

3.安装驱动内核模块

可以查看/proc/devices文件，确定驱动是否被注册4.创建设备文件

创建设备文件的命令：

        mknod  设备文件的名字和路径   设备文件类型   驱动的主设备号   次设备号

        例：mknod /dev/mychrdev c 240 0

解析：mknod：创捷设备文件的命令码

           /dev/mychrdev：创建的设备文件的路径和名字

          c 设备文件类型（字符设备文件） d(块设备文件)

          240：主设备号

          0：次设备号 0-255都可以

5.编写应用程序代码测试是否可以关联驱动

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
int main(int argc, char const *argv[])
{
    char buf[128] = {0};
    int fd = open("/dev/mychrdev", O_RDWR);
    if (fd < 0)
    {
        printf("打开设备文件失败\n");
        return -1;
    }
    printf("打开设备文件成功\n");
    //调用read
    read(fd, buf, sizeof(buf));
    //调用write
    write(fd, buf, sizeof(buf));
    //调用close
    close(fd);
    return 0;
}

6.现象

执行应用程序，驱动中的操作方法被回调

4.用户和内核的数据传递

用户空间和内核空间之间无法直接相互访问内存，二者进行数据交互需要使用数据传递函数

4.1 API

头文件 #include <linux/uaccess.h>

函数原型unsigned long copy_to_user(void __user *to, const void *from, unsigned long n)

功能：传递内核空间的数据到用户空间

参数：to：用户空间保存数据的buf首地址

           from：内核空间保存数据的buf首地址

           n：传递的数据长度，以字节为单位

返回值：成功返回0，失败返回未拷贝的字节数

函数原型unsigned log copy_from_user(void *to, const void __user *from, unsigned long n)

功能：传递用户空间的数据到内核空间

参数：to：内核空间保存数据的buf首地址

           from：用户空间保存数据的buf首地址

           n：传递的数据长度，以字节为单位

返回值：成功返回0，失败返回未拷贝的字节数

4.2用户和内核数据传递实例

应用程序代码

#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include<string.h>
int main(int argc, char const *argv[])
{
    char buf[128] = {0};
    int fd = open("/dev/mychrdev", O_RDWR);
    if (fd < 0)
    {
        printf("打开设备文件失败\n");
        return -1;
    }
    printf("打开设备文件成功\n");
    fgets(buf,sizeof(buf),stdin);//在终端读一个字符串
    buf[strlen(buf)-1]='\0';
    
    write(fd, buf, sizeof(buf));//将数据传递给内核
    memset(buf,0,sizeof(buf));//清空数组
    read(fd, buf, sizeof(buf));//将内核空间数据传递到用户
    printf("buf:%s\n",buf);
    close(fd);
    return 0;
}

驱动程序代码 

#include <linux/init.h>
#include <linux/module.h>
#include <linux/fs.h>
#include<linux/uaccess.h>
unsigned int major;
char kbuf[128]={};
// 封装操作方法
int mycdev_open(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
ssize_t mycdev_read(struct file *file, char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    int ret;
    //拷贝数据到用户空间
    ret=copy_to_user(ubuf,kbuf,size);
    if(ret)
    {
        printk("copy_to_user filed\n");
        return -EIO;
    }
    return 0;
}
ssize_t mycdev_write(struct file *file, const char *ubuf, size_t size, loff_t *lof)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    int ret;
    //从用户空间拷贝数据到内核空间
    ret=copy_from_user(kbuf,ubuf,size);
    if(ret)
    {
        printk("copy_from_user filed\n");
        return -EIO;
    }
    return 0;
}
int mycdev_close(struct inode *inode, struct file *file)
{
    printk("%s:%s:%d\n",__FILE__,__func__,__LINE__);
    return 0;
}
// 定义操作方法结构体对象
struct file_operations fops = {
    .open=mycdev_open,
    .read=mycdev_read,
    .write=mycdev_write,
    .release=mycdev_close,
};
static int __init mycdev_init(void)
{
    // 注册字符设备驱动
    major = register_chrdev(0, "mychrdev", &fops);
    if (major < 0)
    {
        printk("字符设备驱动注册失败\n");
        return major;
    }
    printk("注册字符设备驱动成功major=%d\n", major);
    return 0;
}
static void __exit mycdev_exit(void)
{
    //注销字符设备驱动
    unregister_chrdev(major,"mychrdev");
}
module_init(mycdev_init);
module_exit(mycdev_exit);
MODULE_LICENSE("GPL");

现象：在终端输入的字符串可以正常的打印出来，说明用户空间和内核空间数据传递成功

5.物理内存映射相关API

驱动控制硬件需要操作硬件的特殊功能寄存器，但是特殊功能寄存器内存物属于理内存，驱动加载到虚拟内存，想要在驱动中操作硬件寄存器，需要将硬件寄存器内存映射为虚拟内存

#include <linux/io.h>

函数原型：void *ioremap(phys_addr_t paddr, unsigned long size)

功能：映射指定大小的物理内存为虚拟内存

参数：paddr：要映射的物理内存首地址

           size：要映射的物理内存大小

返回值：成功，返回映射成功的虚拟内存首地址，失败，返回NULL

函数原型：void iounmap(const void __iomem *addr)

功能：取消物理内存的映射

参数：addr：要取消的虚拟内存首地址

返回值：无

注：有关字符设备驱动的示例代码，目前可查看上一篇文章"编写驱动代码控制LED灯亮灭"http://t.csdnimg.cn/ZBsgG

土豆学习ing
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
内核模块导出符号表
weixin_51332399的博客
06-07 182
在内核中有的模块都是运行在同一个3-4G的内核空间的，模块和模块间就可以进行函数的直接调用，在调用前只需要将被调用函数的符号表导出即可。在demoA模块中有一个add函数，在demoB模块中想调用demoA模块中的add函数，此时只需要让demoB模块拿到demoA模块中add函数的地址即可。这个过程就使用导出符号表完成。
Linux设备驱动开发详解：基于最新的Linux4.0内核,linux设备驱动开发详解pdf,LINUX
09-10
Linux内核驱动开发详解，基于kernel4.0，对驱动工程师很有帮助
Linux 驱动开发之内核模块开发（四）—— 符号表的导出
知秋一叶
03-09 5192
Linux内核头文件提供了一个方便的方法用来管理符号的对模块外部的可见性,因此减少了命名空间的污染(命名空间的名称可能会与内核其他地方定义的名称冲突),并且适当信息隐藏。 如果你的模块需要输出符号给其他模块使用,应当使用下面的宏定义: EXPORT_SYMBOL(name); EXPORT_SYMBOL_GPL(name);   //只适用于包含GPL许可权的模块；      这两个宏均用于
内核符号导出
lifengxun20121019的专栏
05-11 3405
1、创建实验目录 #mkdir /home/guoqian/4-1-4 #cd /home/guoqian/4-1-4 2、编写内核模块代码calculate.c hello.c Makefile 这是calculate.c 这是hello.c   这是Makefile 3、首先来看不导出内核符号的情况     3、1屏蔽calculate.c      /*EXP
linux内核模块符号导出
123
10-18 271
驱动程序编译生成的 ko 文件是相互独立的，即模块之间变量或者函数在正常情况下无法进行互相访问。而一些复杂的驱动模块需要分层进行设计，这时候就需要用到内核模块符号导出。内核符号导出指的是在内核模块中导出相应的函数和变量，在加载模块时被记录在公共内核符号表中，以供其他模块调用。符号导出所使用的宏为 EXPORT_SYMBOL(sym)和 EXPORT_SYMBOL_GPL(sym)。它们定义在 “/include/linux/export.h”文件中。
linux驱动开发关于内核模块、设备模型、内存管理、模块参数介绍
caiji667788的博客
12-15 722
设备进入操作系统----->总线识别并添加设备信息---->总线利用match函数加载驱动信息绑定该设备（此时已调用class_create建立设备目录在sysfs下）------>初始化该设备 (内核发出创建设备文件信号给上层子系统)------>在子系统生成的目录下，mdev用device-creat函数进行创建设备文件
Linux驱动开发：Linux内核模块、字符设备驱动、IO模型、设备树、GPIO子系统、中断子系统.zip
最新发布
02-29
Linux驱动开发：Linux内核模块、字符设备驱动、IO模型、设备树、GPIO子系统、中断子系统、platform总线驱动、I2C总线驱动、SPI总线驱动 Linux项目是一个开放源代码的操作系统项目，由林纳斯·托瓦兹（Linus Torvalds...
《Linux设备驱动开发详解-基于最新的Linux4.0内核》源码
06-21
《Linux设备驱动开发详解-基于最新的Linux4.0内核》相关源码
基于嵌入式Linux内核的系统设备驱动程序开发设计
01-19
引言　Linux是一个遵循POSIX标准的操作系统。...　基于嵌入式Linux内核的系统设备驱动程序开发设计　设备驱动程序的编写　设备驱动程序是linux内核的一部分，是操作系统内核和机器硬件之间的接口，
Linux内核设备驱动之Linux内核模块加载机制笔记整理
09-15
今天小编就为大家分享一篇关于Linux内核设备驱动之Linux内核模块加载机制笔记整理，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
基于Linux的LoRa内核模块设备驱动程序源码+应用测试程序源码
05-11
这是一个 LoRa 设备驱动程序，作为具有 IEEE 802.15.4 MAC 接口的 Linux 内核模块。 兼容SX1276/77/78/79芯片 文件夹介绍 LoRa：LoRa 源代码和构建文件。 dts-overlay：设备树覆盖板和操作系统。 test-application：...
浅谈Linux内核开发之PCI设备驱动
03-02
本文内容包括：PCI介绍Linux内核对PCI的支持总结参考资料本文介绍了PCI的基本概念，并从Linux内核的角度出发，介绍了PCI设备的初始化以及配置。PCI介绍随着计算机应用的不断更新和发展（比如百兆网卡、视屏流等），...
《Linux设备驱动开发详解——基于最新的Linux4.0内核》源码.zip
02-10
嵌入式Linux开发
Linux内核设备驱动之字符设备驱动笔记整理
09-15
今天小编就为大家分享一篇关于Linux内核设备驱动之字符设备驱动笔记整理，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
传参数到已经编译进内核的驱动
sg656720274的博客
10-28 187
不通过insmod传参数给到驱动
向linux编译好的内核模块传递参数
zhvngchvng的博客
05-13 261
在得到. ko内核模块后，用insmod向linux系统插入内核模块的时候，向该内核模块动态传递参数，需要事先在驱动程序中加入module_param（name,type,perm）函数以确定一个待输入的参数。 然后可以使用 insmod xxx. ko 变量名=取值 的形式来向内核模块传参 同样，传递数组需要用module_param_array（…）函数。 ...
module_param和module_param_array
大猫的博客
06-25 1410
linux驱动: 如何向模块传递参数, module_param和module_param_array 如何向模块传递参数，Linux kernel 提供了一个简单的框架. module_param(name, type, perm) name 既是用户看到的参数名，又是模块内接受参数的变量; type 表示参数的数据类型，是下列之一：byte, short, ushort, int, ...
内核模块（传参和依赖）
qq_52479948的博客
02-16 718
Linux内核模块（传参和依赖）
linux设备驱动开发详解:基于最新的linux4.0内核
06-24
Linux设备驱动开发详解是一本基于最新的Linux 4.0内核的书籍，主要介绍了Linux设备驱动开发的相关知识和技术。 在Linux系统中，设备驱动是让硬件与操作系统进行交互的重要组成部分。本书介绍了Linux设备驱动的编写...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值