526互联

Linux内核学习

发布时间 2023-10-10 22:58:40作者: ⭐⭐-fighting⭐⭐

  1. 文件系统

    1. 什么是文件系统？
      常规认知： 根目录
      文件系统是操作系统用于明确存储设备组织文件的方法。
      以上说的方法：就是文件管理系统（程序），简称文件系统

    2. 文件系统（文件管理系统的方法）的种类有哪些？
      FAT VFAT NTFS EXT1/2/3/4 HFS ....
      树莓派查看文件系统的命令： df -T
      vfat ： boot（bootloader, kernel）
      ext4 ： 根目录
      tmpfs : 内存文件系统

    3. 什么是分区？
      windows: 随意（面向普通用户PC），目录即分区
      C（装系统的位置）也可以随意在C盘存放文件. D盘（用户随意发挥）

    ​

    ​ Linux: 按照功能来分区，每个分区严格存放文件(开发者)
    ​ 嵌入式系统可以分为4个区，分别是
    ​ bootloader、 启动代码
    ​ para、 启动代码向内核传递参数的位置
    ​ kernel、 内核分区
    ​ 根分区等 文件系统结构

    1. 什么是文件系统目录结构？
     常规认知： 根目录，不是分区，和windows不同
    1. 什么虚拟文件系统Virtual File System ？
     **vfs就是对各种文件系统的一个抽象，它为各种文件系统提供了一个通用的接口**，
    1. 虚拟文件系统有什么作用？

    简化应用程序员的开发
    不管是什么文件类型，不管文件是磁盘还是设备，都只用open read write统一操作

内核机构图

用户空间调用一个open会产生一个软中断（中断号是0x80）→系统调用（汇编语言实现的sys_call）→VFS（sys_open）→在驱动链表中根据主设备号和次设备号找到相关的驱动函数→调用驱动函数里面的open，然后设置IO口的电平

linux的设备管理是和文件系统紧密结合的，各种设备都以文件的形式存放在/dev目录下，称为设备文件。应用程序可以打开、关闭和读写这些设备文件，完成对设备的操作，就像操作普通的数据文件一样。为了管理这些设备，系统为设备编了号，每个设备号又分为主设备号和次设备号。主设备号用来区分不同种类的设备，而次设备号用来区分同一类型的多个设备
image

sudo mknod zjn c 8 1 //手动生成设备

如何编译 驱动代码，把驱动代码放在/deivers/char下，然后修改Makefile下的obj-.参数改为pin4driver2.ko

编译的指令为：ARCH=arm CROSS COMPILE=arm-linux-gnueabihf-KERNEL=kernel7 make modules

在树莓派下执行sudo insmod pin4driver2.ko加载内核驱动

Linux内核驱动基础框架

1、驱动代码的编写

pin4test.c
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <asm/io.h>

static struct class *pin4_class;
static struct device *pin4_dev;

static dev_t devno;                // 设备号
static int major = 231;            // 主设备号
static int minor = 0;              // 次设备号
static char *module_name = "pin4"; // 模块名

// led_open函数
static int pin4_open(struct inode *inode, struct file *file)
{
    printk("pin4_open\n");

    return 0;
}

// led_write函数
static ssize_t pin4_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    printk("pin4_writer\n");
    return 0;
}

static struct file_operations pin4_fops = {
    .owner = THIS_MODULE,
    .open = pin4_open,
    .write = pin4_write,
};

int __init pin4_drv_init(void)
{
    int ret;
    devno = MKDEV(major, minor);                           // 创建设备号
    ret = register_chrdev(major, module_name, &pin4_fops); // 注册驱动，告诉内核，把这个驱动加入到内核的链表中

    pin4_class = class_create(THIS_MODULE, "myfirstdemo"); // 让代码在/dev下生成设备
    pin4_class_dev = device_create(pin4_class, NULL, devno, NULL, module_name);

    return 0;
}

void __exit pin4_drv_exit(void)
{
    device_destroy(pin4_class, devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name); // 卸载驱动
}

module_init(pin4_drv_init); // 内核加载驱动时，这个宏会被调用
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");

2、内核驱动编译

  • 把驱动代码拷贝到/driver/char
  • 修改Makefile，告诉编译器，要编译该驱动文件
  • ARCH=arm CROSS COMPILE=arm-linux-gnueabihf-KERNEL=kernel7 make modules

驱动测试步骤

1、内核驱动装载：sudo insmod pin4driver2.ko

2、驱动加载后生成设备 比如 /dev/pin4,通过sudo chmod 666 /dev/pin4添加访问权限

3、运行测试程序调用驱动

4、内核的printk是内合成的printf，通过dmesg查看打印信息

  • dmesg | grep pin4 可以查看内核打印信息

  • lsmod是列出内核所有的驱动模块 rmmod可以删除内核的驱动模块

地址

1、总线地址

cpu能够访问内存的范围

现象：装了3位的win7系统，明明内存条8G，可是系统只识别了3.8G ， 装了64位，才能识别到8g

32位能表示/访问 4，294，967，296bit

bit 4，294，967，296

kbit 4，194，304

mbit 4，096

gbit 4

树莓派32位， 1G 949M

2、物理地址

硬件实际地址或绝对地址

3、虚拟地址

逻辑（基于算法的地址（软件层面的地址）假地址）称为虚拟地址

在内核中访问的地址是虚拟地址，不能直接使用物理地址，在使用物理地址前，要提前映射成虚拟地址

BCM2835 树莓派3b cpu的型号， 它是ARM-cotexxA53架构

内核的页表映射

md5sum

驱动两大利器

  1. 电路图：通过电路图找到寄存器
  2. 芯片手册

芯片手册第六章

GPFSEL0 GPIO Function Select 0 功能选择 输出/输入（GPIO Function Select Registers）32位

14-12bit 001 = GPIO Pin4 is an output

GPSET1 GPIO Pin Output Set 0 输出1

0 = No effect

1 = Set GPIO pin n

GPCLR0 GPIO Pin Output Clear 0 清0

0 = No effect 9

1 = Clear GPIO pin nop

树莓派寄存器地址参考这篇博客

volatile 1、指令不会因编译器的优化而省略 ，2、且要求每次直接读值

image

image

驱动代码
#include <linux/fs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <asm/io.h>

static struct class *pin4_class;
static struct device *pin4_dev;

static dev_t devno;                // 设备号
static int major = 231;            // 主设备号
static int minor = 0;              // 次设备号
static char *module_name = "pin4"; // 模块名

volatile unsigned int* GPFSEL0 = NULL;
volatile unsigned int* GPSET0 = NULL;
volatile unsigned int* GPCLR0 = NULL;

// led_write函数
static ssize_t pin4_read(struct file *file1, const char __user *buf, size_t size, loff_t *ppos)
{
    printk("pin4_read\n");
    return 0;
}
// led_open函数
static int pin4_open(struct inode *inode, struct file *file)
{
    printk("pin4_open\n");
    //配置pin4引脚为输出引脚， bit 12--14 配置成 001
    *GPFSEL0 &= ~(0x6 << 12 );
    *GPFSEL0 |= (0x1 << 12 );

    return 0;
}

// led_write函数
static ssize_t pin4_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    int userCmd;

    printk("pin4_writer\n");
    //获取上层write函数的值
    copy_from_user(&userCmd,buf,count);
    //根据值来操作io口，高电平，或者低电平
    printk("get value\n");
    if(userCmd == 1){
        printk("set 1\n");
        *GPSET0 |= 0x1 << 4;
    }else if(userCmd == 0){
        printk("set 0 \n");
        *GPCLR0 |= 0x1 << 4;
    }else{
        printk("undo \n");
    }

    return 0;
}

static struct file_operations pin4_fops = {
    .owner = THIS_MODULE,
    .open = pin4_open,
    .write = pin4_write,
};

int __init pin4_drv_init(void)//驱动入口
{
    int ret;
    devno = MKDEV(major, minor);                           // 创建设备号
    ret = register_chrdev(major, module_name, &pin4_fops); // 注册驱动，告诉内核，把这个驱动加入到内核的链表中

    pin4_class = class_create(THIS_MODULE, "myfirstdemo"); // 让代码在/dev下自动生成设备
    pin4_class_dev = device_create(pin4_class, NULL, devno, NULL, module_name); //创建设备文件

    GPFSEL0=(volatile unsigned int *)ioremap(0x3f200000,4); // 物理地址转换成虚拟地址，io口寄存器映射成普通内存单元进行访问
    GPSET0 = (volatile unsigned int *)ioremap(0x3f20001C,4);
    GPCLR0 = (volatile unsigned int *)ioremap(0x3f200028,4);

    return 0;
}

void __exit pin4_drv_exit(void)
{
    device_destroy(pin4_class, devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name); // 卸载驱动
}

module_init(pin4_drv_init); // 内核加载驱动时，这个宏会被调用
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");#include <linux/fs.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/device.h>
#include <linux/uaccess.h>
#include <linux/types.h>
#include <asm/io.h>

static struct class *pin4_class;
static struct device *pin4_dev;

static dev_t devno;                // 设备号
static int major = 231;            // 主设备号
static int minor = 0;              // 次设备号
static char *module_name = "pin4"; // 模块名

volatile unsigned int* GPFSEL0 = NULL;
volatile unsigned int* GPSET0 = NULL;
volatile unsigned int* GPCLR0 = NULL;

// led_write函数
static ssize_t pin4_read(struct file *file1, const char __user *buf, size_t size, loff_t *ppos)
{
    printk("pin4_read\n");
    return 0;
}
// led_open函数
static int pin4_open(struct inode *inode, struct file *file)
{
    printk("pin4_open\n");
    //配置pin4引脚为输出引脚， bit 12--14 配置成 001
    *GPFSEL0 &= ~(0x6 << 12 );
    *GPFSEL0 |= (0x1 << 12 );

    return 0;
}

// led_write函数
static ssize_t pin4_write(struct file *file, const char __user *buf, size_t count, loff_t *ppos)
{
    int userCmd;

    printk("pin4_writer\n");
    //获取上层write函数的值
    copy_from_user(&userCmd,buf,count);
    //根据值来操作io口，高电平，或者低电平
    printk("get value\n");
    if(userCmd == 1){
        printk("set 1\n");
        *GPSET0 |= 0x1 << 4;
    }else if(userCmd == 0){
        printk("set 0 \n");
        *GPCLR0 |= 0x1 << 4;
    }else{
        printk("undo \n");
    }

    return 0;
}

static struct file_operations pin4_fops = {
    .owner = THIS_MODULE,
    .open = pin4_open,
    .write = pin4_write,
};

int __init pin4_drv_init(void)//驱动入口
{
    int ret;
    devno = MKDEV(major, minor);                           // 创建设备号
    ret = register_chrdev(major, module_name, &pin4_fops); // 注册驱动，告诉内核，把这个驱动加入到内核的链表中

    pin4_class = class_create(THIS_MODULE, "myfirstdemo"); // 让代码在/dev下自动生成设备
    pin4_class_dev = device_create(pin4_class, NULL, devno, NULL, module_name); //创建设备文件

    GPFSEL0=(volatile unsigned int *)ioremap(0x3f200000,4); // 物理地址转换成虚拟地址，io口寄存器映射成普通内存单元进行访问
    GPSET0 = (volatile unsigned int *)ioremap(0x3f20001C,4);
    GPCLR0 = (volatile unsigned int *)ioremap(0x3f200028,4);

    return 0;
}

void __exit pin4_drv_exit(void)
{
    device_destroy(pin4_class, devno);
    class_destroy(pin4_class);
    unregister_chrdev(major, module_name); // 卸载驱动
}

module_init(pin4_drv_init); // 内核加载驱动时，这个宏会被调用
module_exit(pin4_drv_exit);
MODULE_LICENSE("GPL v2");
上层代码
#include<sys/types.h>
#include<sys/stat.h>
#include<fcntl.h>
#include<stdio.h>

int main(int argc, char const *argv[])
{
    int fd;
    int cmd;

    fd = open("/dev/pin4",O_RDWR);
    if(fd < 0){
        printf("open failed \n");
        perror("resion:");
    }else{
        printf("open success");
    }
    printf("input command: 1/0 \n 1:pin4 high \n  0:pin4  LOW\n")
    scanf("$d",&cmd);

    fd = write(fd,$cmd,1);

    return 0;
}