Linux 块设备驱动实验

前面我们都是在学习字符设备驱动,本章我们来学习一下块设备驱动框架,块设备驱动是
Linux 三大驱动类型之一。块设备驱动要远比字符设备驱动复杂得多,不同类型的存储设备又
对应不同的驱动子系统,本章我们重点学习一下块设备相关驱动概念,不涉及到具体的存储设
备。最后,我们使用ALPHA 开发板板载RAM 模拟一个块设备,学习块设备驱动框架的使用。

什么是块设备?

块设备是针对存储设备的,比如SD 卡、EMMC、NAND Flash、Nor Flash、SPI Flash、机
械硬盘、固态硬盘等。因此块设备驱动其实就是这些存储设备驱动,块设备驱动相比字符设备
驱动的主要区别如下:
①、块设备只能以块为单位进行读写访问,块是linux 虚拟文件系统(VFS)基本的数据传输
单位。字符设备是以字节为单位进行数据传输的,不需要缓冲。
②、块设备在结构上是可以进行随机访问的,对于这些设备的读写都是按块进行的,块设
备使用缓冲区来暂时存放数据,等到条件成熟以后再一次性将缓冲区中的数据写入块设备中。
这么做的目的为了提高块设备寿命,大家如果仔细观察的话就会发现有些硬盘或者NAND Flash
就会标明擦除次数(flash 的特性,写之前要先擦除),比如擦除100000 次等。因此,为了提高块
设备寿命引入了缓冲区,数据先写入到缓冲区中,等满足一定条件后再一次性写入到真正的物
理存储设备中,这样就减少了对块设备的擦除次数,提高了块设备寿命。
字符设备是顺序的数据流设备,字符设备是按照字节进行读写访问的。字符设备不需要缓
冲区,对于字符设备的访问都是实时的,而且也不需要按照固定的块大小进行访问。
块设备结构的不同其I/O 算法也会不同,比如对于EMMC、SD 卡、NAND Flash 这类没有
任何机械设备的存储设备就可以任意读写任何的扇区(块设备物理存储单元)。但是对于机械硬
盘这样带有磁头的设备,读取不同的盘面或者磁道里面的数据,磁头都需要进行移动,因此对
于机械硬盘而言,将那些杂乱的访问按照一定的顺序进行排列可以有效提高磁盘性能,linux 里
面针对不同的存储设备实现了不同的I/O 调度算法。

块设备驱动框架

block_device 结构体

linux 内核使用block_device 表示块设备,block_device 为一个结构体,定义在
include/linux/fs.h 文件中,结构体内容如下:

示例代码68.2.1.1 block_device 结构体
1 struct block_device {
2 dev_t bd_dev; /* not a kdev_t - it's a search key */
3 int bd_openers;
4 struct inode *bd_inode; /* will die */
5 struct super_block *bd_super;
6 struct mutex bd_mutex; /* open/close mutex */
7 struct list_head bd_inodes;
8 void * bd_claiming;
9 void * bd_holder;
10 int bd_holders;
11 bool bd_write_holder;
12 #ifdef CONFIG_SYSFS
13 struct list_head bd_holder_disks;
14 #endif
15 struct block_device *bd_contains;
16 unsigned bd_block_size;
17 struct hd_struct *bd_part;
18 /*number of times partitions within this device have been opened.*/
19 unsigned bd_part_count;
20 int bd_invalidated;
21 struct gendisk *bd_disk;
22 struct request_queue *bd_queue;
23 struct list_head bd_list;
24 /*
25 * Private data. You must have bd_claim'ed the block_device
26 * to use this. NOTE: bd_claim allows an owner to claim
27 * the same device multiple times, the owner must take special
28 * care to not mess up bd_private for that case.
29 */
30 unsigned long bd_private;
31
32 /* The counter of freeze processes */
33 int bd_fsfreeze_count;
34 /* Mutex for freeze */
35 struct mutex bd_fsfreeze_mutex;
36 };

对于block_device 结构体,我们重点关注一下第21 行的bd_disk 成员变量,此成员变量为
gendisk 结构体指针类型。内核使用block_device 来表示一个具体的块设备对象,比如一个硬盘
或者分区,如果是硬盘的话bd_disk 就指向通用磁盘结构gendisk。
1、注册块设备
和字符设备驱动一样,我们需要向内核注册新的块设备、申请设备号,块设备注册函数为
register_blkdev,函数原型如下:

int register_blkdev(unsigned int major, const char *name)

函数参数和返回值含义如下:
major:主设备号。
name:块设备名字。
返回值:如果参数major 在1~255 之间的话表示自定义主设备号,那么返回0 表示注册成
功,如果返回负值的话表示注册失败。如果major 为0 的话表示由系统自动分配主设备号,那
么返回值就是系统分配的主设备号(1~255),如果返回负值那就表示注册失败。
2、注销块设备
和字符设备驱动一样,如果不使用某个块设备了,那么就需要注销掉,函数为
unregister_blkdev,函数原型如下:

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

函数参数和返回值含义如下:
major:要注销的块设备主设备号。
name:要注销的块设备名字。
返回值:无。

gendisk 结构体

linux 内核使用gendisk 来描述一个磁盘设备,这是一个结构体,定义在include/linux/genhd.h
中,内容如下:

示例代码68.2.2.1 gendisk 结构体
1 struct gendisk {
2 /* major, first_minor and minors are input parameters only,
3 * don't use directly. Use disk_devt() and disk_max_parts().
4 */
5 int major; /* major number of driver */
6 int first_minor;
7 int minors; /* maximum number of minors, =1 for
8 * disks that can't be partitioned. */
9
10 char disk_name[DISK_NAME_LEN]; /* name of major driver */
11 char *(*devnode)(struct gendisk *gd, umode_t *mode);
12
13 unsigned int events; /* supported events */
14 unsigned int async_events; /* async events, subset of all */
15
16 /* Array of pointers to partitions indexed by partno.
17 * Protected with matching bdev lock but stat and other
18 * non-critical accesses use RCU. Always access through
19 * helpers.
20 */
21 struct disk_part_tbl __rcu *part_tbl;
22 struct hd_struct part0;
23
24 const struct block_device_operations *fops;
25 struct request_queue *queue;
26 void *private_data;
27
28 int flags;
29 struct device *driverfs_dev; // FIXME: remove
30 struct kobject *slave_dir;
31
32 struct timer_rand_state *random;
33 atomic_t sync_io; /* RAID */
34 struct disk_events *ev;
35 #ifdef CONFIG_BLK_DEV_INTEGRITY
36 struct blk_integrity *integrity;
37 #endif
38 int node_id;
39 };

我们简单看一下gendisk 结构体中比较重要的几个成员变量:
第5 行,major 为磁盘设备的主设备号。
第6 行,first_minor 为磁盘的第一个次设备号。
第7 行,minors 为磁盘的次设备号数量,也就是磁盘的分区数量,这些分区的主设备号一
样,次设备号不同。
第21 行,part_tbl 为磁盘对应的分区表,为结构体disk_part_tbl 类型,disk_part_tbl 的核心
是一个hd_struct 结构体指针数组,此数组每一项都对应一个分区信息。
第24 行,fops 为块设备操作集,为block_device_operations 结构体类型。和字符设备操作
集file_operations 一样,是块设备驱动中的重点!
第25 行,queue 为磁盘对应的请求队列,所以针对该磁盘设备的请求都放到此队列中,驱
动程序需要处理此队列中的所有请求。
编写块的设备驱动的时候需要分配并初始化一个gendisk,linux 内核提供了一组gendisk 操
作函数,我们来看一下一些常用的API 函数。
1、申请gendisk
使用gendisk 之前要先申请,allo_disk 函数用于申请一个gendisk,函数原型如下:

struct gendisk *alloc_disk(int minors)

函数参数和返回值含义如下:
minors:次设备号数量,也就是gendisk 对应的分区数量。
返回值:成功:返回申请到的gendisk,失败:NULL。
2、删除gendisk
如果要删除gendisk 的话可以使用函数del_gendisk,函数原型如下:

void del_gendisk(struct gendisk *gp)

函数参数和返回值含义如下:
gp:要删除的gendisk。
返回值:无。
3、将gendisk 添加到内核
使用alloc_disk 申请到gendisk 以后系统还不能使用,必须使用add_disk 函数将申请到的
gendisk 添加到内核中,add_disk 函数原型如下:

void add_disk(struct gendisk *disk)

函数参数和返回值含义如下:
disk:要添加到内核的gendisk。
返回值:无。
4、设置gendisk 容量
每一个磁盘都有容量,所以在初始化gendisk 的时候也需要设置其容量,使用函数
set_capacity,函数原型如下:

void set_capacity(struct gendisk *disk, sector_t size)

函数参数和返回值含义如下:
disk:要设置容量的gendisk。
size:磁盘容量大小,注意这里是扇区数量。块设备中最小的可寻址单元是扇区,一个扇区
一般是512 字节,有些设备的物理扇区可能不是512 字节。不管物理扇区是多少,内核和块设备驱动之间的扇区都是512 字节。所以set_capacity 函数设置的大小就是块设备实际容量除以
512 字节得到的扇区数量。比如一个2MB 的磁盘,其扇区数量就是(210241024)/512=4096。
返回值:无。
5、调整gendisk 引用计数
内核会通过get_disk 和put_disk 这两个函数来调整gendisk 的引用计数,根据名字就可以
知道,get_disk 是增加gendisk 的引用计数,put_disk 是减少gendisk 的引用计数,这两个函数原
型如下所示:

truct kobject *get_disk(struct gendisk *disk)
void put_disk(struct gendisk *disk)

68.2.3 block_device_operations 结构体
和字符设备的file _operations 一样,块设备也有操作集,为结构体block_device_operations,
此结构体定义在include/linux/blkdev.h 中,结构体内容如下:

示例代码68.2.3.1 block_device_operations 结构体
1 struct block_device_operations {
2 int (*open) (struct block_device *, fmode_t);
3 void (*release) (struct gendisk *, fmode_t);
4 int (*rw_page)(struct block_device *, sector_t, struct page *,
int rw);
5 int (*ioctl) (struct block_device *, fmode_t, unsigned,
unsigned long);
6 int (*compat_ioctl) (struct block_device *, fmode_t, unsigned,
unsigned long);
7 long (*direct_access)(struct block_device *, sector_t,
8 void **, unsigned long *pfn, long size);
9 unsigned int (*check_events) (struct gendisk *disk,
10 unsigned int clearing);
11 /* ->media_changed() is DEPRECATED, use ->check_events() instead */
12 int (*media_changed) (struct gendisk *);
13 void (*unlock_native_capacity) (struct gendisk *);
14 int (*revalidate_disk) (struct gendisk *);
15 int (*getgeo)(struct block_device *, struct hd_geometry *);
16 /* this callback is with swap_lock and sometimes page table lock held */
17 void (*swap_slot_free_notify) (struct block_device *,
unsigned long);
18 struct module *owner;
19 };

可以看出,block_device_operations 结构体里面的操作集函数和字符设备的file_operations
操作集基本类似,但是块设备的操作集函数比较少,我们来看一下其中比较重要的几个成员函
数:
第2 行,open 函数用于打开指定的块设备。
第3 行,release 函数用于关闭(释放)指定的块设备。
第4 行,rw_page 函数用于读写指定的页。
第5 行,ioctl 函数用于块设备的I/O 控制。
第6 行,compat_ioctl 函数和ioctl 函数一样,都是用于块设备的I/O 控制。区别在于在64
位系统上,32 位应用程序的ioctl 会调用compat_iotl 函数。在32 位系统上运行的32 位应用程
序调用的就是ioctl 函数。
第15 行,getgeo 函数用于获取磁盘信息,包括磁头、柱面和扇区等信息。
第18 行,owner 表示此结构体属于哪个模块,一般直接设置为THIS_MODULE。
68.2.4 块设备I/O 请求过程
大家如果仔细观察的话会在block_device_operations 结构体中并没有找到read 和write 这样
的读写函数,那么块设备是怎么从物理块设备中读写数据?这里就引出了块设备驱动中非常重
要的request_queue、request 和bio。
1、请求队列request_queue
内核将对块设备的读写都发送到请求队列request_queue 中,request_queue 中是大量的
request(请求结构体),而request 又包含了bio,bio 保存了读写相关数据,比如从块设备的哪个
地址开始读取、读取的数据长度,读取到哪里,如果是写的话还包括要写入的数据等。我们先
来看一下request_queue ,这是一个结构体,定义在文件include/linux/blkdev.h 中,由于
request_queue 结构体比较长,这里就不列出来了。大家回过头看一下示例代码68.2.2.1 的gendisk
结构体就会发现里面有一个request_queue 结构体指针类型成员变量queue,也就说在编写块设
备驱动的时候,每个磁盘(gendisk)都要分配一个request_queue。
①、初始化请求队列
我们首先需要申请并初始化一个request_queue,然后在初始化gendisk 的时候将这个
request_queue 地址赋值给gendisk 的queue 成员变量。使用blk_init_queue 函数来完成
request_queue 的申请与初始化,函数原型如下:

request_queue *blk_init_queue(request_fn_proc *rfn, spinlock_t *lock)

函数参数和返回值含义如下:
rfn:请求处理函数指针,每个request_queue 都要有一个请求处理函数,请求处理函数
request_fn_proc 原型如下:

void (request_fn_proc) (struct request_queue *q)

请求处理函数需要驱动编写人员自行实现。
lock:自旋锁指针,需要驱动编写人员定义一个自旋锁,然后传递进来。,请求队列会使用
这个自旋锁。
返回值:如果为NULL 的话表示失败,成功的话就返回申请到的request_queue 地址。
②、删除请求队列
当卸载块设备驱动的时候我们还需要删除掉前面申请到的request_queue,删除请求队列使
用函数blk_cleanup_queue,函数原型如下:

void blk_cleanup_queue(struct request_queue *q)

函数参数和返回值含义如下:
q:需要删除的请求队列。
返回值:无。

③、分配请求队列并绑定制造请求函数
blk_init_queue 函数完成了请求队列的申请以及请求处理函数的绑定,这个一般用于像机械
硬盘这样的存储设备,需要I/O 调度器来优化数据读写过程。但是对于EMMC、SD 卡这样的
非机械设备,可以进行完全随机访问,所以就不需要复杂的I/O 调度器了。对于非机械设备我
们可以先申请request_queue,然后将申请到的request_queue 与“制造请求”函数绑定在一起。
先来看一下request_queue 申请函数blk_alloc_queue,函数原型如下:

struct request_queue *blk_alloc_queue(gfp_t gfp_mask)

函数参数和返回值含义如下:
gfp_mask:内存分配掩码,具体可选择的掩码值请参考include/linux/gfp.h 中的相关宏定义,
一般为GFP_KERNEL。
返回值:申请到的无I/O 调度的request_queue。
我们需要为blk_alloc_queue 函数申请到的请求队列绑定一个“制造请求”函数(其他参考资
料将其直接翻译为“制造请求”函数)。这里我们需要用到函数blk_queue_make_request,函数
原型如下:

void blk_queue_make_request(struct request_queue *q, make_request_fn *mfn)

函数参数和返回值含义如下:
q:需要绑定的请求队列,也就是blk_alloc_queue 申请到的请求队列。
mfn:需要绑定的“制造”请求函数,函数原型如下:

void (make_request_fn) (struct request_queue *q, struct bio *bio)

“制造请求”函数需要驱动编写人员实现。
返回值:无。
一般blk_alloc_queue 和blk_queue_make_request 是搭配在一起使用的,用于那么非机械的
存储设备、无需I/O 调度器,比如EMMC、SD 卡等。blk_init_queue 函数会给请求队列分配一
个I/O 调度器,用于机械存储设备,比如机械硬盘等。
2、请求request
请求队列(request_queue)里面包含的就是一系列的请求(request),request 是一个结构体,定
义在include/linux/blkdev.h 里面,这里就不展开request 结构体了,太长了。request 里面有一个
名为“bio”的成员变量,类型为bio 结构体指针。前面说了,真正的数据就保存在bio 里面,
所以我们需要从request_queue 中取出一个一个的request,然后再从每个request 里面取出bio,
最后根据bio 的描述讲数据写入到块设备,或者从块设备中读取数据。
①、获取请求
我们需要从request_queue 中依次获取每个request,使用blk_peek_request 函数完成此操作,
函数原型如下:

request *blk_peek_request(struct request_queue *q)

函数参数和返回值含义如下:
q:指定request_queue。
返回值:request_queue 中下一个要处理的请求(request),如果没有要处理的请求就返回
NULL。
②、开启请求
使用blk_peek_request 函数获取到下一个要处理的请求以后就要开始处理这个请求,这里
要用到blk_start_request 函数,函数原型如下:

void blk_start_request(struct request *req)

函数参数和返回值含义如下:
req:要开始处理的请求。
返回值:无。
③、一步到位处理请求
我们也可以使用blk_fetch_request 函数来一次性完成请求的获取和开启,blk_fetch_request
函数很简单,内容如下:

示例代码68.2.4.1 blk_fetch_request 函数源码
1 struct request *blk_fetch_request(struct request_queue *q)
2 {
3 struct request *rq;
4
5 rq = blk_peek_request(q);
6 if (rq)
7 blk_start_request(rq);
8 return rq;
9 }

可以看出,blk_fetch_request 就是直接调用了blk_peek_request 和blk_start_request 这两个函
数。
④、其他和请求有关的函数
关于请求的API 还有很多,常见的见表68.2.4.1:
在这里插入图片描述

表68.2.4.1 请求相关API 函数
3、bio 结构
每个request 里面会有多个bio,bio 保存着最终要读写的数据、地址等信息。上层应用程序
对于块设备的读写会被构造成一个或多个bio 结构,bio 结构描述了要读写的起始扇区、要读写
的扇区数量、是读取还是写入、页偏移、数据长度等等信息。上层会将bio 提交给I/O 调度器,
I/O 调度器会将这些bio 构造成request 结构,而一个物理存储设备对应一个request_queue,
request_queue 里面顺序存放着一系列的request。新产生的bio 可能被合并到request_queue 里现
有的request 中,也可能产生新的request,然后插入到request_queue 中合适的位置,这一切都
是由I/O 调度器来完成的。request_queue、request 和bio 之间的关系如图68.2.4.1 所示:
每个块设备对应一个request_queue
在这里插入图片描述
图68.2.4.1 request_queue、request 和bio 之间的关系
bio 是个结构体,定义在include/linux/blk_types.h 中,结构体内容如下:

示例代码68.2.4.2 bio 结构体
1 struct bio {
2 struct bio *bi_next; /* 请求队列的下一个bio */
3 struct block_device *bi_bdev; /* 指向块设备*/
4 unsigned long bi_flags; /* bio状态等信息*/
5 unsigned long bi_rw; /* I/O操作,读或写*/
6 struct bvec_iter bi_iter; /* I/O操作,读或写*/
7 unsigned int bi_phys_segments;
8 unsigned int bi_seg_front_size;
9 unsigned int bi_seg_back_size;
10 atomic_t bi_remaining;
11 bio_end_io_t *bi_end_io;
12 void *bi_private;
13 #ifdef CONFIG_BLK_CGROUP
14 /*
15 * Optional ioc and css associated with this bio. Put on bio
16 * release. Read comment on top of bio_associate_current().
17 */
18 struct io_context *bi_ioc;
19 struct cgroup_subsys_state *bi_css;
20 #endif
21 union {
22 #if defined(CONFIG_BLK_DEV_INTEGRITY)
23 struct bio_integrity_payload *bi_integrity;
24 #endif
25 };
26
27 unsigned short bi_vcnt; /* bio_vec列表中元素数量*/
28 unsigned short bi_max_vecs; /* bio_vec列表长度*/
29 atomic_t bi_cnt; /* pin count */
30 struct bio_vec *bi_io_vec; /* bio_vec列表*/
31 struct bio_set *bi_pool;
32 struct bio_vec bi_inline_vecs[0];
33 };

重点来看一下第6 行和第30 行,第6 行为bvec_iter 结构体类型的成员变量,第30 行为
bio_vec 结构体指针类型的成员变量。
bvec_iter 结构体描述了要操作的设备扇区等信息,结构体内容如下:

示例代码68.2.4.3 bvec_iter 结构体
1 struct bvec_iter {
2 sector_t bi_sector; /* I/O请求的设备起始扇区(512字节) */
3 unsigned int bi_size; /* 剩余的I/O数量*/
4 unsigned int bi_idx; /* blv_vec中当前索引*/
5 unsigned int bi_bvec_done; /* 当前bvec中已经处理完成的字节数*/
6 };

bio_vec 结构体描述了内容如下:

示例代码68.2.4.4 bio_vec 结构体
1 struct bio_vec {
2 struct page *bv_page; /* 页*/
3 unsigned int bv_len; /* 长度*/
4 unsigned int bv_offset; /* 偏移*/
5 };

可以看出bio_vec 就是“page,offset,len”组合,page 指定了所在的物理页,offset 表示所处
页的偏移地址,len 就是数据长度。
我们对于物理存储设备的操作不外乎就是将RAM 中的数据写入到物理存储设备中,或者
将物理设备中的数据读取到RAM 中去处理。数据传输三个要求:数据源、数据长度以及数据
目的地,也就是你要从物理存储设备的哪个地址开始读取、读取到RAM 中的哪个地址处、读
取的数据长度是多少。既然bio 是块设备最小的数据传输单元,那么bio 就有必要描述清楚这
些信息,其中bi_iter 这个结构体成员变量就用于描述物理存储设备地址信息,比如要操作的扇
区地址。bi_io_vec 指向bio_vec 数组首地址,bio_vec 数组就是RAM 信息,比如页地址、页偏
移以及长度,“页地址”是linux 内核里面内存管理相关的概念,这里我们不深究linux 内存管
理,我们只需要知道对于RAM 的操作最终会转换为页相关操作。
bio、bvec_iter 以及bio_vec 这三个机构体之间的关系如图68.4.2.2 所示:
在这里插入图片描述
图68.4.2.2 bio、bio_iter 与bio_vec 之间的关系
①、遍历请求中的bio
前面说了,请求中包含有大量的bio,因此就涉及到遍历请求中所有bio 并进行处理。遍历
请求中的bio 使用函数__rq_for_each_bio,这是一个宏,内容如下:

示例代码68.2.4.5 __rq_for_each_bio 函数
#define __rq_for_each_bio(_bio, rq) \
if ((rq->bio)) \
for (_bio = (rq)->bio; _bio; _bio = _bio->bi_next)

_bio 就是遍历出来的每个bio,rq 是要进行遍历操作的请求,_bio 参数为bio 结构体指针类
型,rq 参数为request 结构体指针类型。
②、遍历bio 中的所有段
bio 包含了最终要操作的数据,因此还需要遍历bio 中的所有段,这里要用到
bio_for_each_segment 函数,此函数也是一个宏,内容如下:

示例代码68.2.4.6 bio_for_each_segment 函数
#define bio_for_each_segment(bvl, bio, iter) \
__bio_for_each_segment(bvl, bio, iter, (bio)->bi_iter)

第一个bvl 参数就是遍历出来的每个bio_vec,第二个bio 参数就是要遍历的bio,类型为
bio 结构体指针,第三个iter 参数保存要遍历的bio 中bi_iter 成员变量。
③、通知bio 处理结束
如果使用“制造请求”,也就是抛开I/O 调度器直接处理bio 的话,在bio 处理完成以后要
通过内核bio 处理完成,使用bio_endio 函数,函数原型如下:

bvoid bio_endio(struct bio *bio, int error)

函数参数和返回值含义如下:
bio:要结束的bio。
error:如果bio 处理成功的话就直接填0,如果失败的话就填个负值,比如-EIO。
返回值:无

使用请求队列实验

关于块设备架构就讲解这些,接下来我们使用开发板上的RAM 模拟一段块设备,也就是
ramdisk,然后编写块设备驱动。

实验程序编写

本实验对应的例程路径为:开发板光盘-> 2、Linux 驱动例程-> 24_ramdisk_withrequest。
首先是传统的使用请求队列的时候,也就是针对机械硬盘的时候如何编写驱动。由于实验
程序稍微有点长,因此我们就分步骤来讲解一下,本实验参考自linux 内核drivers/block/z2ram.c。
打开实验源码,我们先来一下一相关的宏定义和结构体,代码如下:

示例代码68.3.1.1 宏定义和结构体
1 #include <linux/types.h>
......
21 #include <asm/io.h>
22 /***************************************************************
23 Copyright © ALIENTEK Co., Ltd. 1998-2029. All rights reserved.
24 文件名: ramdisk.c
25 作者: 左忠凯
26 版本: V1.0
27 描述: 内存模拟硬盘,实现块设备驱动,本驱动使用请求队列。
28 : 参考:drivers/block/z2ram.c
29 其他: 无
30 论坛: www.openedv.com
31 日志: 初版V1.0 2020/5/22 左忠凯创建
32 ***************************************************************/
33
34 #define RAMDISK_SIZE (2 * 1024 * 1024) /* 容量大小为2MB */
35 #define RAMDISK_NAME "ramdisk" /* 名字*/
36 #define RADMISK_MINOR 3 /* 表示三个磁盘分区!不是次设备号为3!*/
37
38 /* ramdisk设备结构体*/
39 struct ramdisk_dev{
40 int major; /* 主设备号*/
41 unsigned char *ramdiskbuf; /* ramdisk内存空间,用于模拟块设备*/
42 spinlock_t lock; /* 自旋锁*/
43 struct gendisk *gendisk; /* gendisk */
44 struct request_queue *queue;/* 请求队列*/
45 };
46
47 struct ramdisk_dev ramdisk; /* ramdisk设备*/

第34~36 行,实验相关宏定义,RAMDISK_SIZE 就是模拟块设备的大小,这里设置为2MB,
也就是说本实验中的虚拟块设备大小为2MB 。RAMDISK_NAME 为本实验名字,
RADMISK_MINOR 是本实验此设备号数量,注意不是次设备号!此设备号数量决定了本块设
备的磁盘分区数量。
第39~45 行,ramdisk 的设备结构体。
第47 行,定义一个ramdisk 示例。
接下来看一下驱动模块的加载与卸载,内容如下:

示例代码68.3.1.2 驱动模块加载与卸载
1 /*
2 * @description : 驱动入口函数
3 * @param : 无
4 * @return : 无
5 */
6 static int __init ramdisk_init(void)
7 {
8 int ret = 0;
9
10 /* 1、申请用于ramdisk内存*/
11 ramdisk.ramdiskbuf = kzalloc(RAMDISK_SIZE, GFP_KERNEL);
12 if(ramdisk.ramdiskbuf == NULL) {
13 ret = -EINVAL;
14 goto ram_fail;
15 }
16
17 /* 2、初始化自旋锁*/
18 spin_lock_init(&ramdisk.lock);
19
20 /* 3、注册块设备*/
21 ramdisk.major = register_blkdev(0, RAMDISK_NAME); /* 自动分配*/
22 if(ramdisk.major < 0) {
23 goto register_blkdev_fail;
24 }
25 printk("ramdisk major = %d\r\n", ramdisk.major);
26
27 /* 4、分配并初始化gendisk */
28 ramdisk.gendisk = alloc_disk(RADMISK_MINOR);
29 if(!ramdisk.gendisk) {
30 ret = -EINVAL;
31 goto gendisk_alloc_fail;
32 }
33
34 /* 5、分配并初始化请求队列*/
35 ramdisk.queue = blk_init_queue(ramdisk_request_fn,
&ramdisk.lock);
36 if(!ramdisk.queue) {
37 ret = -EINVAL;
38 goto blk_init_fail;
39 }
40
41 /* 6、添加(注册)disk */
42 ramdisk.gendisk->major = ramdisk.major; /* 主设备号*/
43 ramdisk.gendisk->first_minor = 0; /*起始次设备号) */
44 ramdisk.gendisk->fops = &ramdisk_fops; /* 操作函数*/
45 ramdisk.gendisk->private_data = &ramdisk; /* 私有数据*/
46 ramdisk.gendisk->queue = ramdisk.queue; /* 请求队列*/
47 sprintf(ramdisk.gendisk->disk_name, RAMDISK_NAME);/* 名字*/
48 set_capacity(ramdisk.gendisk, RAMDISK_SIZE/512); /* 设备容量(单位
为扇区)*/
49 add_disk(ramdisk.gendisk);
50
51 return 0;
52
53 blk_init_fail:
54 put_disk(ramdisk.gendisk);
55 gendisk_alloc_fail:
56 unregister_blkdev(ramdisk.major, RAMDISK_NAME);
57 register_blkdev_fail:
58 kfree(ramdisk.ramdiskbuf); /* 释放内存*/
59 ram_fail:
60 return ret;
61 }
62
63 /*
64 * @description : 驱动出口函数
65 * @param : 无
66 * @return : 无
67 */
68 static void __exit ramdisk_exit(void)
69 {
70 /* 释放gendisk */
71 del_gendisk(ramdisk.gendisk);
72 put_disk(ramdisk.gendisk);
73
74 /* 清除请求队列*/
75 blk_cleanup_queue(ramdisk.queue);
76
77 /* 注销块设备*/
78 unregister_blkdev(ramdisk.major, RAMDISK_NAME);
79
80 /* 释放内存*/
81 kfree(ramdisk.ramdiskbuf);
82 }
83
84 module_init(ramdisk_init);
85 module_exit(ramdisk_exit);
86 MODULE_LICENSE("GPL");
87 MODULE_AUTHOR("zuozhongkai");

ramdisk_init 和ramdisk_exit 这两个函数分别为驱动入口以及出口函数,我们依次来看一下
这两个函数。
第11 行,因为本实验是使用一块内存模拟真实的块设备,因此这里先使用kzalloc 函数申
请用于ramdisk 实验的内存,大小为2MB。
第18 行,初始化一个自旋锁,blk_init_queue 函数在分配并初始化请求队列的时候需要用
到一次自旋锁。
第21 行,使用register_blkdev 函数向内核注册一个块设备,返回值就是注册成功的块设备
主设备号。这里我们让内核自动分配一个主设备号,因此register_blkdev 函数的第一个参数为
0。
第28 行,使用alloc_disk 分配一个gendisk。
第35 行,使用blk_init_queue 函数分配并初始化一个请求队列,请求处理函数为
ramdisk_request_fn,具体的块设备读写操作就在此函数中完成,这个需要驱动开发人员去编写,
稍后讲解。
第42~47 行,初始化第28 行申请到的gendisk,重点是第44 行设置gendisk 的fops 成员变
量,也就是设置块设备的操作集。这里设置为ramdisk_fops,需要驱动开发人员自行编写实现,
稍后讲解。
第48 行,使用set_capacity 函数设置本块设备容量大小,注意这里的大小是扇区数,不是
字节数,一个扇区是512 字节。
第49 行,gendisk 初始化完成以后就可以使用add_disk 函数将gendisk 添加到内核中,也
就是向内核添加一个磁盘设备。
ramdisk_exit 函数就比较简单了,在卸载块设备驱动的时候需要将前面申请的内容都释放
掉。第71 和72 行使用put_disk 和del_gendis 函数释放前面申请的gendisk,第75 行使用
blk_cleanup_queue 函数消除前面申请的请求队列,第78 行使用unregister_blkdev 函数注销前面
注册的块设备,最后调用kfree 来释放掉申请的内存。
在ramdisk_init 函数中设置了gendisk 的fops 成员变量,也就是块设备的操作集,具体内容
如下:

示例代码68.3.1.3 gendisk 的fops 操作集
1 /*
2 * @description : 打开块设备
3 * @param - dev : 块设备
4 * @param - mode : 打开模式
5 * @return : 0 成功;其他失败
6 */
7 int ramdisk_open(struct block_device *dev, fmode_t mode)
8 {
9 printk("ramdisk open\r\n");
10 return 0;
11 }
12
13 /*
14 * @description : 释放块设备
15 * @param - disk : gendisk
16 * @param - mode : 模式
17 * @return : 0 成功;其他失败
18 */
19 void ramdisk_release(struct gendisk *disk, fmode_t mode)
20 {
21 printk("ramdisk release\r\n");
22 }
23
24 /*
25 * @description : 获取磁盘信息
26 * @param - dev : 块设备
27 * @param - geo : 模式
28 * @return : 0 成功;其他失败
29 */
30 int ramdisk_getgeo(struct block_device *dev,
struct hd_geometry *geo)
31 {
32 /* 这是相对于机械硬盘的概念*/
33 geo->heads = 2; /* 磁头*/
34 geo->cylinders = 32; /* 柱面*/
35 geo->sectors = RAMDISK_SIZE / (2 * 32 *512); /* 磁道上的扇区数量*/
36 return 0;
37 }
38
39 /*
40 * 块设备操作函数
41 */
42 static struct block_device_operations ramdisk_fops =
43 {
44 .owner = THIS_MODULE,
45 .open = ramdisk_open,
46 .release = ramdisk_release,
47 .getgeo = ramdisk_getgeo,
48 };

第42~48 行就是块设备的操作集block_device_operations,本例程实现的比较简单,仅仅
实现了open、release 和getgeo,其中open 和release 函数都是空函数。重点是getgeo 函数,第
30~37 行就是getgeo 的具体实现,此函数用户获取磁盘信息,信息保存在参数geo 中,为结构
体hd_geometry 类型,如下:

示例代码68.3.1.4 hd_geometry 结构体
1 struct hd_geometry {
2 unsigned char heads; /* 磁头*/
3 unsigned char sectors; /*一个磁道上的扇区数量*/
4 unsigned short cylinders; /* 柱面*/
5 unsigned long start;
6 };

本例程中设置ramdisk 有2 个磁头(head)、一共有32 个柱面(cylinderr)。知道磁盘总容量、
磁头数、柱面数以后我们就可以计算出一个磁道上有多少个扇区了,也就是hd_geometry 中的
sectors 成员变量。
最后就是非常重要的请求处理函数,使用blk_init_queue 函数初始化队列的时候需要指定
一个请求处理函数,本例程中注册的请求处理函数如下所示:

示例代码68.3.1.5 请求处理函数
1 /*
2 * @description : 处理传输过程
3 * @param-req : 请求
4 * @return : 无
5 */
6 static void ramdisk_transfer(struct request *req)
7 {
8 unsigned long start = blk_rq_pos(req) << 9; /* blk_rq_pos获取到的是
扇区地址,左移9位转换为字节地址*/
9 unsigned long len = blk_rq_cur_bytes(req); /* 大小*/
10
11 /* bio中的数据缓冲区
12 * 读:从磁盘读取到的数据存放到buffer中
13 * 写:buffer保存这要写入磁盘的数据
14 */
15 void *buffer = bio_data(req->bio);
16
17 if(rq_data_dir(req) == READ) /* 读数据*/
18 memcpy(buffer, ramdisk.ramdiskbuf + start, len);
19 else if(rq_data_dir(req) == WRITE) /* 写数据*/
20 memcpy(ramdisk.ramdiskbuf + start, buffer, len);
21
22 }
23
24 /*
25 * @description : 请求处理函数
26 * @param-q : 请求队列
27 * @return : 无
28 */
29 void ramdisk_request_fn(struct request_queue *q)
30 {
31 int err = 0;
32 struct request *req;
33
34 /* 循环处理请求队列中的每个请求*/
35 req = blk_fetch_request(q);
36 while(req != NULL) {
37
38 /* 针对请求做具体的传输处理*/
39 ramdisk_transfer(req);
40
41 /* 判断是否为最后一个请求,如果不是的话就获取下一个请求
42 * 循环处理完请求队列中的所有请求。
43 */
44 if (!__blk_end_request_cur(req, err))
45 req = blk_fetch_request(q);
46 }
47 }

请求处理函数的重要内容就是完成从块设备中读取数据,或者向块设备中写入数据。首先
来看一下29~47 行的ramdisk_request_fn 函数,这个就是请求处理函数。此函数只要一个参数
q,为request_queue 结构体指针类型,也就是要处理的请求队列,因此ramdisk_request_fn 函数
的主要工作就是依次处理请求队列中的所有请求。第35 行,首先使用blk_fetch_request 函数获
取请求队列中第一个请求,如果请求不为空的话就调用ramdisk_transfer 函数进行对请求做进一
步的处理,然后就是while 循环依次处理完请求队列中的每个请求。第44 行使用
__blk_end_request_cur 函数检查是否为最后一个请求,如果不是的话就继续获取下一个,直至整
个请求队列处理完成。
ramdisk_transfer 函数完成清楚中的数据处理,第8 行调用blk_rq_pos 函数从请求中获取要
操作的块设备扇区地址,第9 行使用blk_rq_cur_bytes 函数获取请求要操作的数据长度,第15
行使用bio_data 函数获取请求中bio 保存的数据。第17 ~20 行调用rq_data_dir 函数判断当前是
读还是写,如果是写的话就将bio 中的数据拷贝到ramdisk 指定地址(扇区),如果是读的话就从
ramdisk 中的指定地址(扇区)读取数据放到bio 中。

运行测试

编译上一小节的驱动,得到ramdisk.ko 驱动模块,然后拷贝到rootfs/lib/modules/4.1.15 目
录中,重启开发板,进入到目录lib/modules/4.1.15 中。输入如下命令加载ramdisk.ko 这个驱动
模块。

depmod //第一次加载驱动的时候需要运行此命令
modprobe ramdisk.ko //加载驱动模块

1、查看ramdisk 磁盘
驱动加载成功以后就会在/dev/目录下生成一个名为“ramdisk”的设备,输入如下命令查看
ramdisk 磁盘信息:

fdisk -l //查看磁盘信息

上述命令会将当前系统中所有的磁盘信息都打印出来,其中就包括了ramdisk 设备,如图
68.3.2.1 所示:
在这里插入图片描述

图68.3.2.1 ramdisk 磁盘信息
从图68.3.2.1 可以看出,ramdisk 已经识别出来了,大小为2MB,但是同时也提示/dev/ramdisk
没有分区表,因为我们还没有格式化/dev/ramdisk。
2、格式化/dev/ramdisk
使用mkfs.vfat 命令格式化/dev/ramdisk,将其格式化成vfat 格式,输入如下命令:

mkfs.vfat /dev/ramdisk

格式化完成以后就可以挂载/dev/ramdisk 来访问了,挂载点可以自定义,这里笔者就将其挂
载到/tmp 目录下,输入如下命令:

mount /dev/ramdisk /tmp

挂载成功以后就可以通过/tmp 来访问ramdisk 这个磁盘了,进入到/tmp 目录中,可以通过
vi 命令新建一个txt 文件来测试磁盘访问是否正常。

不使用请求队列实验

实验程序编写

本实验对应的例程路径为:开发板光盘-> 2、Linux 驱动例程-> 25_ramdisk_norequest。
前面我们学习了如何使用请求队列,请求队列会用到I/O 调度器,适合机械硬盘这种存储
设备。对于EMMC、SD、ramdisk 这样没有机械结构的存储设备,我们可以直接访问任意一个
扇区,因此可以不需要I/O 调度器,也就不需要请求队列了,这个我们前面已经说过了。本实
验就来学习一下如何使用“制造请求”方法,本实验在上一个实验的基础上修改而来,参考了
linux 内核drivers/block/zram/zram_drv.c。重点来看一下与上一个实验不同的地方,首先是驱动
入口函数ramdisk_init,ramdisk_init 函数大部分和上一个实验相同,只是本实验中改为使用
blk_queue_make_request 函数设置“制造请求”函数,修改后的ramdisk_init 函数内容如下(有省
略):

示例代码68.4.1.1 ramdisk_init 函数
1 static int __init ramdisk_init(void)
2 {
......
29
30 /* 5、分配请求队列*/
31 ramdisk.queue = blk_alloc_queue(GFP_KERNEL);
32 if(!ramdisk.queue){
33 ret = -EINVAL;
34 goto blk_allo_fail;
35 }
36
37 /* 6、设置“制造请求”函数*/
38 blk_queue_make_request(ramdisk.queue, ramdisk_make_request_fn);
39
40 /* 7、添加(注册)disk */
41 ramdisk.gendisk->major = ramdisk.major; /* 主设备号*/
42 ramdisk.gendisk->first_minor = 0; /* 起始次设备号*/
43 ramdisk.gendisk->fops = &ramdisk_fops; /* 操作函数*/
44 ramdisk.gendisk->private_data = &ramdisk; /* 私有数据*/
45 ramdisk.gendisk->queue = ramdisk.queue; /* 请求队列*/
46 sprintf(ramdisk.gendisk->disk_name, RAMDISK_NAME); /* 名字*/
47 set_capacity(ramdisk.gendisk, RAMDISK_SIZE/512); /* 设备容量*/
48 add_disk(ramdisk.gendisk);
49
......
60 return ret;
61 }

ramdisk_init 函数中第31~38 行就是与上一个实验不同的地方,这里使用blk_alloc_queue
和blk_queue_make_request 这两个函数取代了上一个实验的blk_init_queue 函数。
第31 行,使用blk_alloc_queue 函数申请一个请求队列。
第38 行,使用blk_queue_make_request 函数设置“制造请求”函数,这里设置的制造请
求函数为ramdisk_make_request_fn,这个需要驱动编写人员去实现,稍后讲解。
第43 行,设置块设备操作集为ramdisk_fops,和上一个实验一模一样,这里就不讲解
了。
接下来重点看一下“制造请求”函数ramdisk_make_request_fn,函数内容如下:

示例代码68.4.1.2 ramdisk_make_request_fn 函数
1 /*
2 * @description : “制造请求”函数
3 * @param-q : 请求队列
4 * @return : 无
5 */
6 void ramdisk_make_request_fn(struct request_queue *q,
struct bio *bio)
7 {
8 int offset;
9 struct bio_vec bvec;
10 struct bvec_iter iter;
11 unsigned long len = 0;
12
13 offset = (bio->bi_iter.bi_sector) << 9; /* 获取设备的偏移地址*/
14
15 /* 处理bio中的每个段*/
16 bio_for_each_segment(bvec, bio, iter){
17 char *ptr = page_address(bvec.bv_page) + bvec.bv_offset;
18 len = bvec.bv_len;
19
20 if(bio_data_dir(bio) == READ) /* 读数据*/
21 memcpy(ptr, ramdisk.ramdiskbuf + offset, len);
22 else if(bio_data_dir(bio) == WRITE) /* 写数据*/
23 memcpy(ramdisk.ramdiskbuf + offset, ptr, len);
24 offset += len;
25 }
26 set_bit(BIO_UPTODATE, &bio->bi_flags);
27 bio_endio(bio, 0);
28 }

虽然ramdisk_make_request_fn 函数第一个参数依旧是请求队列,但是实际上这个请求队列
不包含真正的请求,所有的处理内容都在第二个bio 参数里面,所以ramdisk_make_request_fn
函数里面是全部是对bio 的操作。
第13 行,直接读取bio 的bi_iter 成员变量的bi_sector 来获取要操作的设备地址(扇区)。
第16~25 行,使用bio_for_each_segment 函数循环获取bio 中的每个段,然后对其每个段进
行处理。
第17 行,根据bio_vec 中页地址以及偏移地址转换为真正的数据起始地址。
第18 行,获取要处理的数据长度,也就是bio_vec 的bv_len 成员变量。
第20~23 行,和上一个实验一样,要操作的块设备起始地址知道了,数据的存放地址以及
长度也知道,接下来就是根据读写操作将数据从块设备中读出来,或者将数据写入到块设备中。
第27 行,调用bio_endio 函数,结束bio。

运行测试

测试方法和上一个实验一样,参考68.3.2 小节即可。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.rhkb.cn/news/174735.html

如若内容造成侵权/违法违规/事实不符,请联系长河编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

图像分类任务ViT与CNN谁更胜一筹?DeepMind用实验证明

精华置顶 墙裂推荐&#xff01;小白如何1个月系统学习CV核心知识&#xff1a;链接 点击CV计算机视觉&#xff0c;关注更多CV干货 今天跟大家分享DeepMind发表的一篇技术报告&#xff0c;通过实验得出&#xff0c;CNN与ViT的架构之间虽然存在差异&#xff0c;但同等计算资源的预…

人工智能AI 全栈体系(九)

第一章 神经网络是如何实现的 如何用神经网络处理不等长文本的方法&#xff1f; 八、循环神经网络&#xff08;RNN: Recurrent Neural Network&#xff09; 处理不等长文本的神经网络 – 循环神经网络 RNN。 1. 从句子理解说起 上次讲了用词向量表示词&#xff0c;一句话也…

北邮22级信通院数电:Verilog-FPGA(7)第七周实验(2):BCD七段显示译码器(关注我的uu们加群咯~)

北邮22信通一枚~ 跟随课程进度更新北邮信通院数字系统设计的笔记、代码和文章 持续关注作者 迎接数电实验学习~ 获取更多文章&#xff0c;请访问专栏&#xff1a; 北邮22级信通院数电实验_青山如墨雨如画的博客-CSDN博客 关注作者的uu们可以进群啦~ 目录 一.verilog代码…

Kubernetes Label Selector

Author&#xff1a;rab 目录 前言一、Labels1.1 定义1.2 案例1.2.1 节点标签1.2.2 对象标签 二、Selector2.1 Node Selector2.2 Service Selector2.3 Deployment Selector2.4 StatefulSet Selector2.5 DaemonSet Selector2.6 HorizontalPodAutoscaler Selector2.7 NetworkPolic…

【C】柔性数组

柔性数组 也许你从来没有听说过柔性数组&#xff08;flexible array)这个概念&#xff0c;但是它确实是存在的。 C99 中&#xff0c;结构中的最后一个元素允许是未知大小的数组&#xff0c;这就叫做『柔性数组』成员。 例如&#xff1a; 柔性数组的特点 结构中的柔性数组成员前…

ZKP7.1 Polynomial Commitments Based on Error-correcting Codes (Background)

ZKP学习笔记 ZK-Learning MOOC课程笔记 Lecture 7: Polynomial Commitments Based on Error-correcting Codes (Yupeng Zhang) Recall: common paradigm for efficient SNARK A polynomial commitment scheme A polynomial interactive oracle proof (IOP) SNARK for gene…

CAN总线通信协议

Reference video: 趋近于完美的通讯 CAN总线&#xff01;4分钟看懂&#xff01; CAN通信精华整理&#xff0c;汽车工程师必备技能&#xff0c;一个视频带你轻松掌握&#xff01; 写在前面&#xff1a;CAN通信就三个要点 - 波特率的配置 - 过滤寄存器的配置与理解&#xff08;…

数组与链表算法-单向链表算法

目录 数组与链表算法-单向链表算法 C代码 单向链表插入节点的算法 C代码 单向链表删除节点的算法 C代码 对单向链表进行反转的算法 C代码 单向链表串接的算法 C代码 数组与链表算法-单向链表算法 在C中&#xff0c;若以动态分配产生链表节点的方式&#xff0c;则可以…

“第五十五天”

定点数&#xff1a; 原码的乘法&#xff1a; 乘法的符号位是单独处理的&#xff08;通过对被乘数和乘数的符号位进行异或实现&#xff09;&#xff0c;数值位去绝对值进行运算。这里的乘法实际上是通过多次加法实现的。 这里被乘数是放在x寄存器&#xff0c;乘数放在MQ寄存器…

【音视频|wav】wav音频文件格式详解

&#x1f601;博客主页&#x1f601;&#xff1a;&#x1f680;https://blog.csdn.net/wkd_007&#x1f680; &#x1f911;博客内容&#x1f911;&#xff1a;&#x1f36d;嵌入式开发、Linux、C语言、C、数据结构、音视频&#x1f36d; &#x1f923;本文内容&#x1f923;&a…

洛谷 B2009 计算 (a+b)/c 的值 C++代码

目录 题目描述 AC Code 切记 题目描述 题目网址&#xff1a;计算 (ab)/c 的值 - 洛谷 AC Code #include<bits/stdc.h> using namespace std; int main() {int a,b,c;cin>>a>>b>>c;cout<<(ab)/c<<endl;return 0; } 切记 不要复制题…

Netty复习:(2)IdleStateHandler的用法

一、handler定义&#xff1a; package handler;import io.netty.channel.ChannelHandlerContext; import io.netty.channel.ChannelInboundHandlerAdapter;public class MyChatServerHandler3 extends ChannelInboundHandlerAdapter {Overridepublic void userEventTriggered(…

Pytorch指定数据加载器使用子进程

torch.utils.data.DataLoader(train_dataset, batch_sizebatch_size, shuffleTrue,num_workers4, pin_memoryTrue) num_workers 参数是 DataLoader 类的一个参数&#xff0c;它指定了数据加载器使用的子进程数量。通过增加 num_workers 的数量&#xff0c;可以并行地读取和预处…

分布式:一文吃透分布式锁,Redis/Zookeeper/MySQL实现

目录 一、项目准备spring项目数据库 二、传统锁演示超卖现象使用JVM锁解决超卖解决方案JVM失效场景 使用一个SQL解决超卖使用mysql悲观锁解决超卖使用mysql乐观锁解决超卖四种锁比较Redis乐观锁集成Redis超卖现象redis乐观锁解决超卖 三、分布式锁概述四、Redis分布式锁实现方案…

Linux 文件系统简介

文章目录 一、磁盘简介1.1 简介1.2 机械硬盘与固态硬盘1.2.1 机械磁盘&#xff08;HDD&#xff09;1.2.2 固态磁盘&#xff08;SSD&#xff09;1.2.3 I/O操作 二、文件系统简介2.1. 简介2.2 文件系统特点2.3 Linux文件系统 三、文件数据存储方式3.1 连续存储3.2 链接表存储3.3 …

前端知识与基础应用#2

标签的分类 关于标签我们可以分为 &#xff1a; 单标签&#xff1a;img, br hr 双标签&#xff1a;a&#xff0c;h,div 按照属性可分为&#xff1a; 块儿标签&#xff08;自己独自占一行&#xff09;&#xff1a;h1-h6, p,div 行内&#xff08;内联&#xff09;标签&#xff08…

One-to-N N-to-One: Two Advanced Backdoor Attacks Against Deep Learning Models

One-to-N & N-to-One: Two Advanced Backdoor Attacks Against Deep Learning Models----《一对N和N对一&#xff1a;针对深度学习模型的两种高级后门攻击》 1对N&#xff1a; 通过控制同一后门的不同强度触发多个后门 N对1&#xff1a; 只有当所有N个后门都满足时才会触发…

3.5每日一题(求齐次方程组的特解)

1、判断类型选择方法&#xff1a;看出为齐次方程&#xff08;次幂都一样&#xff09; 2、 化为变量可分离&#xff1b;按变量可分离的方法求出通解&#xff08;此题等式两边同时除以 x &#xff09; 3、把x1&#xff0c;y0带入通解&#xff0c;定常数C&#xff0c;求出特解 …

用大白话聊聊SpringBoot的自动配置原理(面试题详解)

首先&#xff0c;SpringBoot的自动配置不等于自动装配&#xff01; 自动配置是Auto-Configuration&#xff0c;针对的是SpringBoot中的配置类&#xff0c; 而自动装配是Autowire&#xff0c;针对的是Spring中的依赖注入。 进入主题&#xff1a; 自动配置简单来说就是自动去把…

java八股文(基础篇)

面向过程和面向对象的区别 面向过程&#xff1a;在解决问题时&#xff0c;特别自定义函数编写一步一步的步骤解决问题。 面向对象&#xff1a;其特点就是 继承&#xff0c;多态&#xff0c;继承&#xff0c;在解决问题时&#xff0c;不再注重函数的编写&#xff0c;而在于注重…