一,内核模块
模块可以控制内核的大小,一旦被加载,它和内核中其它功能一样.
用户可以lsmod分析/proc/modules文件.或 cat /proc/modules.
模块被加载后,会生成/sys/module/hello目录,包括refcnt文件和sections目录.
modprobe比insmod强大,它在加载时还可以加载模块所依赖的其它模块.modprobe -r filename卸载模块及其依赖.
modinfo<模块名>可获得模块信息,包括filename,license,author,description,alias,vermagic,depends等
模块加载
static int __init initialization_function( void )
{
//初始化代码 __init的代码在连接时都放在.init.text.其函数指针放在.initcall.init区段.
初始化时会调用__init函数,完成后就释放text区段(.init.text .initcall.init).
}
module_init( initialization_function ); 成功则返回0,失败则-ENODEV，-ENOMEM等,<linux/errno.h>,用户可用perror打印.
通过request_module(const char *fmt,...);
request_module("char-major-%d-%d",MAJOR(dev),MINOR(dev));加载模块
模块卸载
static void __exit cleanup_function( void )
{
//释放代码
}
module_exit( clean_function ); 无返回
模块加载函数注册了xxx,卸载就要注销xxx.
模块加载函数申请了内存,卸载就要释放内存.
模块加载函数申请了硬件资源(中断,DMA通道,IO端口,IO内存等),卸载就要释放这些资源.
模块加载函数开启了硬件,卸载就要关闭硬件.
其实__init和__exit是两个宏.
#define __init __attribute__ ((__section__(".init.text")))
#define __exit __attribute__ ((__section__(".exit.text")))
#define __initdata __attribute__ ((__section__(".init.data")))
#define __exitdata __attribute__ ((__sectione__)(".exit.data"))
模块许可证声明
MODULE_LICENSE("Dual BSD/GPL");
模块参数(可选)
module_param( 参数名, 参数类型, 参数读/写权限 )
参数类型: byte,short,ushort,int,uint,long,ulong,charp(字符指针),bool或invbool.编译时将此参数类型和定义的类型比较.
读/写权限: 一般为0,不为0时,在/sys/module/目录下会出现以参数名命名的文件节点.文件的权限就是"参数读/写权限".内容是参数的值.
module_param_array( 数组名,数组类型,数组长,参数读/写权限 )
数组长: 数组长指针的变量赋给"数组长",或NULL
static char *book_name = "书名";
static int num = 4000;
module_param( book_name, charp, S_IRUGO );
module_param( num, int, S_IRUGO );
insmod book.ko 不带参数加载,使用模块内的参数默认值,内核输出在日志"/var/log/messages"
insmod book.ko book_name='Book name' num=500 带参数加载.
模块导出符号(可选)
linux2.6的所有内核符号(内核符号表)在 /proc/kallsyms 文件中.
EXPORT_SYMBOL( 符号名 ); 导出内核符号
EXPORT_SYNBOL_GPL( 符号名 ); 用于包含GPL许可权的模块
模块声明和描述(可选)
MODULE_AUTHOR( author );
MODULE_DESCRIPTION( description );
MODULE_VERSION( version_string );
MODULE_DEVICE_TABLE( table_info );
MODULE_ALIAS( alternate_name );
static struct usb_device_id skel_table[] = {
{ USB_DEVICE( USB_SKEL_VENDOR_ID, USB_SKEL_PRODUCT_ID ) },
{ } //表结束
};
MODULE_DEVICE_TABLE( usb, skel_table );
模块的使用计数(可选)
2.4中,模块自身控制计数,通过宏:MOD_INC_USE_COUNT, MOD_DEC_USE_COUNT
2.6中,提供了模块管理计数接口. 此模块管理 struct module *owner域,try_module_put(dev->owner).
int try_module_get( struct module *module ); 在驱动底层使用,如总线驱动或此类设备的共用核心模块.
void module_put( struct module *module );
模块的编译
hello.c Makefile(obj-m:= hello.c)
make -C /usr/src/linux2.6.15.5/ M=/driver_study/ modules
make -C /usr/src/linux2.6.15.5 M=$(pwd) modules
模块与GPL
1,内核编译时 enable loadable module support
2,将.ko文件放入相关目录.
3,文件系统中应包括insmod,lsmod,rmmod等工具,modprobe,rmmod可以不要.
4,用户可以insmod手动添加模块.
5,自动添加在驱动过程中的rc脚本
mount /proc
mount /var
mount /dev/pta
mkdir /var/log
mkdir /var/run
mkdir /var/ftp
mkdir -p /var/spool/cron
mkdir /var/config
...
insmod /usr/lib/company_driver.ko 2> /dev/null
/usr/bin/userprocess
/var/config/rc
二,Linux文件系统与设备文件系统
linux文件操作的系统调用，C库的文件操作函数.
linux文件系统的目录:
/bin /boot /dev /etc /home /lib /lost+found /mnt /opt /proc /root /sbin /tmp /usr /var /sys /initrd
file结构体,在内核中代表一个打开的文件.
struct file
{
union
{ struct list_head fu_list;
struct rcu_head fu_rcuhead;
}f_u;
struct dentry *f_dentry; 与文件关联的目录入口 dentry结构
struct vfsmount *f_vfsmnt;
struct file_operations *f_op; 与文件关联的操作
atomic_t f_count;
unsigned int f_flags; 文件标志,O_RDONLT,O_NOBLOCK,O_SYNC
mode_t f_mode; 文件读写模式,FMODE_READ和FMODE_WRITE
loff_t f_pos; 当前读写位置
struct fown_struct f_owner;
unsigned int f_uid, f_gid;
struct file_ta_state f_ra;
unsigned long f_version;
void *f_security;
void *private_data; 文件私有数据,tty驱动使用,其它驱动可能使用
#ifdef CONFIG_EPOLL
struct list_head f_ep_links; 被fs/eventpoll.c使用,以便连接所有这个文件的钩子(hooks).
spinlock_t f_ep_lock;
#endif
struct address_space *f_mapping;
};
inode结构体,包含文件访问权限,属主,组,大小,生成时间,访问时间,修改时间等信息. 是linux管理file的基本单位,也是vfs连接目录和文件的桥梁.
struct inode
{
...
umode_t i_mode; inode 权限
uid_t i_uid; inode 拥有者 id
gid_t i_gid; inode 所属的群组 id
dev_t i_rdev; 设备编号,高12位是主设备编号,低20位是次设备编号.
loff_t i_size; inode代表的文件大小
struct timespec i_atime; inode最近一次的存取时间
struct timespec i_mtime; inode最近一次的修改时间
struct timespec i_ctime; inode的产生时间
unsigned long i_blksize; inode在做IO时的区块大小
unsigned long i_blocks; inode使用的block数,一个block为512byte.
struct block_device *i_bdev; 块设备的block_device结构体指针.
struct cdev *i_cdev; 字符设备的cdev结构体指针.
...
}
unsigned int imajor( struct inode *inode )
unsigned int iminor( struct inode *inode )
/proc/devices文件包含系统中注册的设备信息,/dev目录中是系统中包含的设备文件.
内核的Documents目录下的 devices.txt文件描述了linux设备号的官方分配情况,由LANANA组织维护.
sysfs文件系统与linux设备模型
2.6引入了sysfs文件系统,用于设备的管理.sysfs与proc,devfs和devpty同级.是一个虚拟的文件系统,包括所有系统硬件的层级视图.
sysfs把系统里的设备和总线组织成一个分级的文件,可以由用户存取.向用户空间导出了内核数据结构和属性.
还向用户展示了设备驱动模型的各组件的层次关系和交叉关系:
block所有的块设备,
device所有的设备并按总线类型组织成层次结构,
bus系统中所有的总线类型
drivers内核中已注册的设备驱动程序
class系统中的设备类型(网卡,声卡,输入设备)
power,firmware
内核将利用以下的数据结构完成linux的设备模型与总线和其他子系统的交互:
kobject,kset,subsystem,device,device_driver,bus_type,class,class_device,class_interface.
1，kobject内核对象: 使得所有设备在底层拥有统一的接口,提供了管理对象的基本能力.是2.6设备模型的核心结构,每个kobject对应sysfs一个目录.
struct kobject
{
char *k_name;
char name[KOBJ_NAME_LEN]; 内核对象的名字
struct kref kref; 对象引用计数,kobject_get(),kobject_put().
struct list_head entry; 用于挂接kobject到kset链表
struct kobject *parent; 父对象指针
struct kest *kest; 所属kset指针
struct kobj_type *ktype; 对象类型描述符的指针
struct dentry *dentry; sysfs文件系统中与该对象对应的文件节点入口
};
struct kobject_type
{
void (*release)(struct kobject *);release函数
struct sysfs_ops * sysfs_ops; 属性操作,store(),show()实现用户空间到设备模型的属性读写.buffer
struct attribute ** default_attrs;sysfs默认属性列表
}
struct ssyfs_ops
{
ssize_t (*show)(struct kobject *, struct attibute *, char *);
ssize_t (*store)(strict kobject *, struct attibute *, const char *, size_t);
}
void kobject_init( struct kobject *kobj );
kref+1,entry指向本身,kset计数+1.
int kobject_set_name( struct kobject *kobj, const char *format, ...);
void kobject_cleanup( struct kobject *kobj );void kobject_release( struct kref *kref );
清除kobject,当0时释放资源.
struct kobject *kobject_get( struct kobject *kobj );
kref+1,同时返回对象的指针.
void kobject_put( struct kobject *kobj );
kref-1,当0时释放资源.
int kobject_add( struct kobject *kobj );
将kobject加入linux设备层次,挂接kobject到kset的list链中.增加父目录中各级kobject的引用计数,
在其parent指向的目录下创建节点,并启动该类型kobject的hotplug函数.
int kobject_register( struct kobject *kobj );
先kobject_init(),再kocject_add().
void kobject_del( struct kobject *kobj );
从linux设备层次(hierarchy)结构中删除kobject.
void kobject_unregister( struct kobject *kobj );
先kobject_del,再kobject_out()减少kref,kref=0则释放kobject.
2，kset内核对象集合:
kobject通过kset组织成层次化的结构,kset是据有相同类型的kobject的集合.
struct kset
{
struct subsystem *subsys; 所在subsystem指针
struct kobj_type *ktype; kset对象属性的指针
struct list_head list; 链接kset中所有kobject的双向链表头
spinlock_t list_lock;
struct kobject kobj; 嵌入的kobject,作为kobject的parent,还用于kset中kobject个数的计数.
struct kset_uevent_ops *uevent_ops;事件操作集
}
kset_int(); kset_get(); kest_put(); kset_add(); kset_del(); kset_register(); kset_unregister()
kobject创建和删除时会产生事件,kset会过滤事件和设置一些事件(热插拔时uevnet_ops执行).这些事件变量被导出到用户空间.
struct kset_uevent_ops
{
int (*filter)(struct kset *kset, struct kobject *kobj); kobject事件过滤
const char *(*name)(struct kest *kset, struct kobject *kobject);
int (*uevent)(struct kset *kset, struct kobject *kobj, char **envp, 新环境变量设置,导出给用户热插拔处理程序
int num_envp, char *buffer, int buffer_size);
}
导出的环境变量:
PCI设备:
ACTION(add/remove),PCA_CLASS(hex的PCI类,子类,接口,c0310),PCI_ID(Vendor:Device,0123:4567),
PCI_SUBSYS_ID(Sub Vendor:Sub Device,89ab:cdef),PCI_SLOT_NAME(Bus:Slot.Func, 00:07.2).
USB设备:
ACTION(add/remove),DEVPATH(/sys/DEVPATH),PRODUCT(idVendor/idProduct/bcdDevice,46d/c281/108),
TYPE(bDeviceClass/bDeviceSubClass/BdeviceProtocal,9/0/0),INTERFACE(bInterfaceClass/bIntergaceSubClass
/bInterfaceProtocal,3/1/1),DEVFS(/proc/bus/usb),DEVICE(USB设备节点路径).
网络设备:
ACTION(register/unregister),INTERFACE(eth0)
输入设备:
ACTION,PRODUCT,NAME,PHYS,EV,KEY,LED
IEEE1394设备:
ACTION,VENDOR_ID,GUID,SPECIFIER_ID,VERSION
用户程序的热插拔脚本根据传入的参数和导出的环境变量采取行动.
if [ "$1" = "usb" ]; then USB热插拔脚本
if [ "$PRODUCT" = "82d/100/0"]; then
if[ "$ACTION" = "add" ]; then
/sbin/modprobe visor
else
/sbin/rmmod visor
fi
fi
fi
3，subsytem 内核对象子系统
subsysten是kset的集合,对应于sysfs的根目录,block_subsys->block;devices_subsys->devices;
struct subsystem 对各个kset中的subsys域设置到subsystem可以将kset加入到同一个subsystem,他们共享一个rw_sem,用于访问kset中的链表.
{
struct kset kset; 内嵌kset对象
struct rw_semaphore rwsem; 互斥信号量
}
void subsystem_init( struct subsystem *subsys );
int subsystem_register( struct subsystem *subsys );
void subsystem_unregister( struct subsystem *subsys );
struct subsytem *sub_sys_get( struct subsystem *subsys );
void subsys_put( struct subssytem *subsys );
4，linux设备模型组件，device,device_driver,bus_type,class,class_device
struct device
{
struct klist klist_children; 设备列表中的子列表
struct klist_node knode_parent; 兄弟节点
struct klist_node knode_driver; 驱动节点
struct klist_node knode_bus; 总线节点
struct device *parent; 父设备
struct kobject kobj; 内嵌的kobject内核对象
charbus_id[BUS_ID_SIZE]; 在总线上的位置
struct device_attribute uevent_attr;
struct semaphore sem;
struct bus_type *bus; 总线
struct device_driver *driver; 驱动程序
void *driver_data; 驱动的私有数据
void *platform_data; 平台特定的数据
void *firmware_data; 固件特定的数据(ACPI,BIOS数据)
struct dev_pm_info power;
u64 *dmamask DMA掩码
u64 coherent_dma_mask;
struct list_head dma_pools; DMA缓冲池
struct dma_coherent_mem *dma_mem;
void (*release)(struct device *dev); 释放设备的方法
};
device结构体描述 设备的信息,层次结构,以及设备与总线的关系.用于其它大的结构体中(struct pci_dev)
device_register() 将一个新的device对象插入设备模型,并在/sys/devices下创建一个目录.
device_unregister()
get_device()
put_device()
struct device_driver
{
}
内嵌kobject实现引用计数和层次管理,get_driver(),put_driver().driver_register()向设备模型插入新的driver对象.对应sysfs文件.
还包括几个函数:处理 探测,移除,电源管理事件.
struct bus_type
{
}
内嵌bus_subsys对象实现总线类型的管理.每个bus_type对应sysfs里的/sys/bus/pci等,里面的2个子目录devices和drivers(对应2个域).
包括几个函数:处理 热插拔,即插即拔,电源管理事件.
struct class
{
}
表示某一类设备,/sys/class,内含一个class_device(表示逻辑设备)链表,class_device里的dev成员连接到物理设备.
也包括几个函数:处理 热插拔,即插即拔,电源管理事件.
struct class_device
{
}
int class_register( struct class *cls );
void class_unregister( struct class *cls );
int class_device_register( struct class_device *class_dev );
void class_device_unregister( struct class_device *class_dev );
当设备加入或离开设备模型时,class_interface中的设备成员函数被调用.
struct class_interface
{
}
5, 属性
bus,device,driver,class模型里都有属性结构.
struct bus_attribute
{
struct attribute attr;
ssize_t (*show)( struct bus_type *, char * buf );
ssize_t (*store)( struct bus_type *, const char *buf, size_t count );
};
struct driver_attribute
{
};
struct class_attribute
{
};
struct class_device_attribute
{
};
有一组宏用于创建和初始化bus_attribute.
有一组函数用于添加和删除bus_attribute.
2.4的devfs设备文件系统
使得设备驱动程序能自主管理它的设备驱动文件.优点:
1,在设备初始化时在/dev下创建文件,卸载设备时删除.
2,驱动程序可以指定设备名,所有者和权限位.用户空间可以修改所有者和权限位.
3,register_chrdev()传递0主设备号可以动态获得主设备号,devfs_register()中指定次设备号.
devfs_handle_t devfs_mk_dir( devfs_handle_t dir, const char *name, void *info ); 创建设备目录
devfs_handle_t devfs_register( devfs_handle_t dir, const char *name, unsigned int flags,创建设备文件
unsigned int major, unsigned int minor, umode_t mode,
void *ops, void *info );
void devfs_unregister( devfs_handle_t de ); 撤消设备文件
实例:
static devfs_handle_t devfs_handle;
static int __init xxx_init( void )
{
int ret;
int i;
ret = register_chrdev( XXX_MAJOR, DEVICE_NAME, &xxx_fops ); 在内核中注销设备
if ( ret < 0 )
{
printk( DEVICE_NAME " can't register major number/n");
return ret;
}
devfs_handle = devfs_register( NULL, DEVICE_NAME, DEVFS_FL_DEFAULT, XXX_MAJOR, 0, 创建设备文件
S_IFCHR | S_IRUSR | S_IWUSR, &xxx_fops, NULL );
...
printk( DEVICE_NAME " initialized/n");
return 0;
}
static void __exit xxx_exit(void)
{
devfs_unregister( devfs_handle ); 撤消设备文件
unregister_chardev( XXX_MAJOR, DEVICE_NAME ); 注销设备
}
module_init( xxx_init );
module_exit( xxx_exit );
2.6的udev设备文件系统
devfs现在不太使用,因为udev的在用户态利用sysfs中的信息 定义规则 并提取主次设备号来动态创建/dev设备文件节点.
udev的组成
设计目标:
1,在用户空间执行;
2,动态建立/删除设备文件;
3,不关心主/次设备号;
4,提供LSB标准的名称;
5,也可提供固定名称
udev分成3个固定的子系统: namedev命名子系统,
libsysfs提供访问sysfs并获取信息的标准接口,
udev提供/dev设备节点文件的动态创建和删除策略.
udev部分承担与namedev和libsysfs库交互的任务.当/sbin/hotplug程序被内核调用时,udev将运行,
工作过程如下:
1,当内核检测到新设备后,内核会在sysfs中生成新的记录并导出设备信息及所发生的事件.
2,udev获取信息,调用namedev命名,调用libsysfs指定主/次设备号,并创建设备文件.设备移出时将/dev文件删除.
namedev通过5个过程来判定设备的命名:
1,标签label/序号serial:检查设备是否有唯一的识别记号.
# USB Epson printer to be called lp_epson
LABEL, BUS="usb", serial="HXOLL0012202323480", NAME="lp_epson"
# USB HP printer to be called lp_hp
LABEL, BUS="usb", serial="W09090207101241330", NAME="lp_hp"
2,设备总线号:检查总线的设备编号.
# sound card with PCI bus id 00:0b.0 to be the first sound card
NUMBER, BUS="pci", id="00:0b.0", NAME="dsp"
# sound card with PCI bus id 00:07.1 to be the second sound card
NUMBER, BUS="pci", id="00:07.1", NAME="dsp1"
3,总线上的拓扑:检查设备在总线上的位置.
#USB mouse plugged into the third port of the first hub to be called mouse0
TOPOLOGY, BUS="usb", place="1.3", NAME="mouse0"
#USB tablet plugged into the second port of the second hub to be called mouse1
TOPOLOGY, BUS="usb", place="2.2", NAME="mouse1"
4,替换名称:检查导出的名称匹配替代的字符串时,就会替代指定的名称.
# ttyUSB1 should always be called visor
REPLACE, KERNEL="ttyUSB1", NAME="visor"
5, 内核提供的名称:如果以上都不符合,用缺省名称.
udev的规则文件
以#为注释,其它每行为规则,由匹配和赋值组成.
匹配: ACTION 匹配行为
KERNEL 匹配内核设备名
BUS 匹配总线类型
SYSFS 匹配从sysfs得到的信息,label,vendor,USB序列号
SUBSYSTEM 匹配子系统名
赋值: NAME 创建设备文件名
SYMLINK 创建链接名
OWNER 设置设备所有者
GROUP 设置设备的组
IMPORT 调用外部程序
例1: SUBSYSTEM=="net", ACTION=="add", SYSFS{address}=="00:0d:87:f6:59:f3", IMPORT="/sbin/rename_netiface %k eth0"
当系统出现新的硬件,其subsys==net,系统对该新硬件采取的action=add,且此硬件在sysfs中的address为 "00:0d:87:f6:59:f3"时:
udev层次的动作为 import=/sbin/rename_netiface. 2个参数;一个%k(kernel对该设备定义的名称),一个 eth0.
例2： BUS="usb", SYSFS{serial}="HX0LL0012202323480"， NAME="lp_epson", SYNLINK="printers/epson_stylus"
udev的固定命名,可根据序列号,devfs不能.
udevinfo -a -p /sys/block/sda 可以查找编写udev规则文件的有用信息.
创建和配置udev
1, tar zxvf udev-114.tar.gz 命令解压
2, make, 产生 test-udev; udevcontrol; udevd; udevinfo; udevmonitor; udevsettle; udevstart; udevtest; udevtrigger工具
3, copy到/sbin, 把解压udev-114.tar.gz后的etc目录复制到/etc下, /etc/udev/udev.conf; /etc/udev/rules.d
4, 编写 启动,停止,重新启动 等 udev脚本.
udev运行脚本:
...
udevtest /sys/class/tty/ttys0 可以用来测试udev对该设备所采取的行动, 用来帮助 udev进行规则文件的调试.
三,c_dev
cdev 结构体
struct cdev
{
struct kobject kobj; 内嵌的kobject对象
struct module *owner; 所属模块
struct file_operations *ops; 文件操作结构体
struct list_head list;
dev_t dev; 设备号, MAJOR(dev_t dev); MINOR(dev_t dev); MKDEV(int major, int minor)
unsigned int count;
}
void cdev_init( struct cdev *cdev, struct file_operations *fops )
{
memset( cdev, 0, sizeof *cdev );
INIT_LIST_HEAD( &cdev->list );
cdev->kobj.ktype = &ktype_cdev_default;
kobject_init( &cdev->kobj );
cdev->ops = fops; 将传入的文件操作结构体赋值给cdev的ops.
}
struct cdev *cdev_alloc( void ) 动态申请一个cdev内存
{
struct cdev *p=kmalloc( sizeof(struct cdev), GFP_KERNEL); 分配cdev内存
if {p} {
memset( p, 0, sizeof(struct cdev) );
p->kobj.ktype = &ktype_cdev_dynamic;
INIT_LIST_HEAD( &p->list );
kocject_init( &p->kobj );
}
return p;
}
void cdev_put( struct cdev *p );
int cdev_add( struct cdev *, dev_t, unsigned ); 向系统添加和删除一个cdev
void cdev_del( struct cdev * );
分配和释放设备号
在cdev_add()添加cdev之前要先申请设备号
int register_chadev_region( dev_t from, unsigned count, const char *name ); 用于已知设备号的情况
int alloc_chrdev_region( dev_t *dev, unsigned baseminor, unsigned count, const char *name ); 动态分配
在cdev_del()之后再释放申请的设备号
void unregister_chrdev_region( dev_t from, unsigned count );
file_operations结构体
struct file_operations
{
struct module *owner; 拥有该结构的指针, THIS_MODULES
loff_t ( *llseek )( struct file *, loff_t, int ); 修改文件当前的读写位置,出错为负
ssize_t ( *read )( struct file *, char __user *, size_t, loff_t * ); 从设备同步读取数据
ssize_t ( *aio_read )( struct kiocb *, char __user *, size_t, loff_t ); 初始化一个异步读操作
ssize_t ( *write )( struct file *, const __user *, size_t, loff_t * ); 向设备发送数据, -EINVAL
ssize_t ( *aio_write )( struct kiocb *, const char __user *, size_t, loff_t ); 初始化一个异步写操作
int (*readdir)( struct file *, void *, filldir_t ); 读取目录,设备文件的字段为NULL
unsigned int ( *poll )( struct file *, struct poll_table_struct * ); 轮询操作,判断是否可以进行非阻塞的读写
int ( *ioctl )( struct inode *, struct file *, unsigned int, unsigned long ); 执行设备I/O控制命令, -EINVAL
long ( *unlocked_ioctl )( struct file *, unsigned int , unsinged long ); 不使用BLK文件系统,将使用此种函数指针代替ioctl
long ( *compat_ioctl )( struct file *, unsigned int, unsigend long ); 在64位系统里,32位的ioctl将用这个函数指针.
int ( *mmap )( struct file *, struct vm_area_struct * ); 请求将设备内存映射到用户进程空间. -ENODEV
int ( *open )( struct inode *, struct file * ); 打开
int ( *flush )( struct file * );
int ( *release )( struct inode *, struct file * ); 关闭
int ( *synch )( struct file *, struct dentry *, int datasync ); 刷新数据
int ( *aio_fsync )( struct kiocb *, int datasync ); 异步 fsync
int ( *fasync )( int, struct fiel *, int ); 通知设备 FASYNC 标志发生变化
int ( *lock )( struct file *, int, struct file_lock * );
ssize_t ( *readv )( struct file *, const struct iovec *, unsigned long, loff_t * ); 分散/聚集形的读操作
ssize_t ( *writev )( struct file *, const struct iovec *, unsigned long, loff_t * ); 分散/聚集形的写操作
ssize_t ( *sendfile )( struct file *, loff_t *, size_t, read_actor_t, void * ); NULL
ssize_t ( *sendpage )( struct file *, struct page *, int, size_t, loff_t *, int ); NULL
unsigned long ( *get_unmapped_area )( struct file *, unsigned long, unsigned long, unsigned long, unsigned long );
在用户进程空间找一个可以映射设备内存空间的位置.
int ( *check_flags )( int ); 允许模块检查传递给 fcntl(F_SETFL...) 调用的标志
int ( *dir_notify )( struct file *filp, unsigned long arg );
int ( *flock )( struct file *, int, struct file_lock * );
}
linux字符设备驱动的组成
1, 字符设备驱动模块加载与卸载.
struct xxx_dev_t
{
struct cdev cdev;
...
}xxx_dev; 设备结构体
static int __init xxx_init( void )
{
...
cdev_init( &xxx.cdev, &xxx_fops );
xxx_dev.cdev.owner = THIS_MODULE;
if ( xxx_major ) 获得字符设备号
{
register_chrdev_region( xxx_dev_no, 1, DEV_NAME );
}
else
{
alloc_chrdrv_region( &xxx_dev_no, 0, 1, DEV_NAME );
}
ret = cdev_add( &xxx_dev.cdev, xxx_dev_no, 1 ); 注册设备
...
}
static void __exit xxx_exit( void )
{
unregister_chrdev_region( xxx_dev_no, 1 );
cdev_del( &xxx_dev.cdev ); 注销设备
...
}
2, 字符设备驱动的file_operations中的成员函数.
ssize_t xxx_read( struct file &filp, char __user *buf, size_t count, loff_t *f_pos )
{
...
copy_to_user(buf, ..., ... ); get_user( val, (int*)arg );
...
}
ssize_t xxx_write( struct file *filp, const char __user *buf, size_t count, loff_t *f_pos )
{
...
copy_from_user( ..., buf, ... ); put_user(val, (int*)arg );
...
}
int xxx_ioctl( struct inode, struct file *filp, unsigned int cmd, unsigned long arg )
{
...
switch ( cmd )
{
case XXX_CMD1:
break;
case XXX_CMD2:
break;
default:
return - ENOTTY;
}
return 0;
}
struct file_operations xxx_ops =
{
.owner = THIS_MODULE,
.read = xxx_read,
.write = xxx_write,
.ioctl = xxx_ioctl,
...
};
globalmem设备驱动实例
1,头文件,宏及设备结构体
2,加载和卸载设备驱动
3,读写函数
4,seek()函数
5,ioctl()函数
6,使用文件私有数据
globalmem驱动在用户空间的验证
四,block_dev
块设备的IO操作特点
块设备需要buffer和块顺序操作.
块设备驱动结构
block_device_operations
struct block_device_operations
{
int ( *open )( struct inode *, struct file * ); 打开设备时调用
int ( *release )( struct inode *, struct file * ); 释放设备
int ( *ioctl )( struct inode *, struct file *, unsigned, unsigned long ); ioctl系统调用的实现
int ( *unlocked_ioctl )( struct file *, unsigned, unsigned long );
long ( *compact_ioctl )( struct file *, unsigned, usngiend long );
int ( *direct_access )( struct block_device *, sector_t, unsigned long * );
int ( *media_changed )( struct gendisk *); 检查介质被改变变量
int ( *revalidate_disk )( struct gendisk ); 介质改变后调用,给驱动一个机会使新介质准备好
int ( *getgeo )( struct block_device *, struct hd_geometry * ); 填充驱动器信息(hd_geometry结构,磁头,扇面,柱面)
struct module *owner; 一个模块指针,指向这个结构体.THIS_MODULE
}
int ( *open )( struct inode *inode, struct file *filp );
int ( *release )( struct inode *inode, struct file *filp );
int ( *ioctl )( struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg );
int ( *madie_changed )( struct gendisk *gd );
int ( *revalidate_disk )( struct gendisk *gd );
int ( *getgeo )( struct block_device *, struct hd_geometry * );
gendisk(通用磁盘),用来表示1个独立的磁盘设备或分区.
struct gendisk
{
int major; 磁盘主设备号
int first_minor; 磁盘次设备主号
int minors; 磁盘次设备号
char disk_name[32]; 设备名称
struct hd_struct **part; 磁盘上的分区信息
struct block_device_operations *fops; 块设备操作结构体
struct request_queue *queue; 请求队列
void private_data; 私有数据
sector_t capacity; 扇区数,512字节为一个扇区
int flags;
char devfs_name;
int number;
struct device *driverfs_dev;
struct kobject kobj;
struct timer_rand_state *random;
int policy;
atomic_t sync_io;
unsigned long stamp;
int flight;
#ifdef CONFIG_SMP
struct disk_stats *dkstats;
#else
struct disk_stats dkstats;
#endif
};
struct gendisk *alloc_disk( int minors );
void add_disk( struct gendisk *gd );
void del_gendisk( struct gendisk *gd );
void set_capacity( struct gendisk *disk, sector_t size ); 设置gendisk的容量,内核和块驱动交互的扇区是512byte.CDROM物理扇区是2KB
request(请求),request_queue(请求队列)和bio(块IO)
1,struct request
{
struct list_head queuelist; 用于链接这个请求到请求队列的链表结构,
blkdev_dequeue_request()用于从队列移除请求.
rq_data_dir( struct request *req)从req获得数据传输的方向,0从设备读,1从设备写.
unsigned long flags; REQ
sector_t sector; 要传送的下一个扇区,驱动使用这3个成员.
unsigned long nr_sectors; 要传送的扇区数目
unsigned int current_nr_sectors; 当前要传送的扇区数目
sector_t hard_sector; 还未完成的,需要完成的下一个扇区,处于块设备层,驱动不应当使用.
unsigned long hard_nr_sectors; 需要被完成的扇区数目
unsigned int hard_cur_sectors; 当前IO操作中待完成的扇区数目
struct bio *bio; 本请求的 bio 结构体链表
struct bio *biotail; 本请求的 bio 结构体链表尾
void *elevator_private;
unsigned short ioprio;
int rq_status;
struct gendisk *rq_disk;
int errors;
unsigned long start_time;
unsigned short nr_phys_segments; 本请求在物理内存中占用的段的数目,如果设备支持SG(scatter/gather,分散/聚集)操作,可申请
sizeof(scatterlis)*nr_phys_segments大小的内存,并进行DMA映射.
int blk_request_map_sg( request_queue_t *q, struct request *req, struct scatterlist *sqlist);
dma_map_sg();
unsigned short nr_hw_segments; 与nr_phys_segments相同,但考虑了系统I/O MMU的remap.
int tag;
char *buffer; 传送的缓冲区地址,内核虚拟地址.
int ref_count; 引用计数.
...
}
2,struct request_queue
{
...
spinlock_t __queue_lock; 保护队列结构体的自旋锁
spinlock_t *queue_lock;
struct kobject kobj; 自带的kobject
unsigned long nr_requests; 最大的请求数量
unsigned int nr_congestion_on;
unsigned int nr_congestion_off;
unsigned int nr_batching;
unsigned short max_sectors; 最大的扇区数
unsigned short max_hw_sectors;
unsigned short max_phys_segments; 最大段数
unsigned short mex_hw_segments;
unsigned short hardset_size; 硬件扇区尺寸
unsigned int max_segmnet_size; 最大的段尺寸
unsigned long seg_boundary_mask; 段边界掩码
unsigned int dma_alignment; DMA传送的内存对齐限制
struct blk_queue_tag *queue_tags;
atomic_t refcnt; 引用计数
unsigned int in_flight;
unsigned int sg_timeout;
unsigned int sg_reserved_size;
int node;
struct list_head drain_list;
struct request *flush_rq;
unsigned char ordered;
}
请求队列存储了设备可以支持的请求的类型,请求的最大数,请求里的最大段数,硬件扇区大小,对齐要求等参数信息.
其结果是如果配置正确,它不会交给设备一个不能处理的请求.
请求队列里有一个插入接口,这个接口允许使用多个IO调度器(elevator).电梯:实现排序合并读写
Noop I/O schedule: 只合并,排序
Anticipatory I/O schedule: 默认的,速度快,但体积大,数据库慢.
Deadline I/O schedule: 比Anticipatory小
CFQ I/O schedule: 所有任务相同带宽,mplayer,xmms效果好.
可以在kernel添加启动参数,改变IO调度方法.
kernel elevator=deadline
1,初始话请求队列,有内存分配,检查返回值.驱动初始化中调用.
request_queue_t *blk_init_queue( request_fn_proc *rfn, spinlock_t *lock );
request_fn_proc: request的处理函数的指针
spinlock: 控制访问队列权限的自旋锁
2,清除请求队列,驱动卸载时调用.
void blk_cleanup_queue( request_queue_t *q );
#define blk_put_queue(q) blk_cleanup_queue((q))
3,分配"请求队列"
request_queue_t *blk_alloc_queue( int gfp_mask );
void blk_queue_make_request( request_queu_t *q, make_request_fn *mfn ); 绑定"请求队列"和制造请求的函数
4,提取请求,标识为活动的请求.
struct request *elv_next_request( request_queue_t *queue );
5,去除请求
void blk_drv_dequeue_request( struct request *req );
void elv_requeue_request( request_queue_t *q, struct request *req ); 插入request
6,启停请求队列
void blk_start_queue( request_queue_t *queue );
void blk_stop_queue( request_queue_t *queue );
7,参数设置
void blk_queue_max_sectors( request_queue_t *queue, unsigned short max ); request的最大扇区数,255
void blk_queue_max_segments( request_queue_t *queue, unsigned short max ); request的最大段(不相邻的区)数目,128
void blk_queue_max_hw_segments( request_queue_t *queue, unsigned short max ); ?
void blk_queue_max_segment_size( request_queue_t *queue, unsigned int max ); request的段的最大字节数,65536
8,通告内核
void blk_queue_bounce_limit( request_queue_t *q, u64 dma_addr );
通告内核块设备DMA时的最高地址,如果某request里超过这个dam_addr,系统会自动分配一个"反弹"缓冲区,代价昂贵.
BLK_BOUNCE_HIGH: 对高端内存页使用"反弹"缓冲区,缺省值.
BLK_BOUNCE_ISA: 在16MB的ISA区执行DMA
BLK_BOUNCE_ANY: 任何地址
void blk_queue_segment_boundary( request_queue_t *q, unsigned long mask );
通告内核,驱动处理的最大内存尺寸.mask缺省0xfffffff
void blk_queue_dma_alignment( request_queue_t *queue, int mask );
通告内核,块设备DMA时的内存对齐限制,缺省0x1ff(512Byte)
void blk_queue_hardset_size( request_queue_t *queue, unsigned short max );
通告内核,块设备扇区大小,内核的request应该是max的倍数或对界,但是内核块设备层与驱动间通信还是以512Byte的扇区为单位.
3,bio(块IO),通常一个bio对应一个I/O请求
struct bio
{
sector_t bi_sector; 要传输的第一个扇区,512Byte
struct bio *bi_next; 下一个bio
struct block_sevice; bi_bdev
unsigned long bi_flags; 状态,命令等,bio_data_dir(bio)宏获得读写方向
unsigned long bi_rw; 低位代表读写,高为代表优先级
unsigned short bi_vcnt; bio_vec数量
unsigned short bi_idx; 当前bvl_vec索引
unsigned short bi_phys_segments; 不相邻的物理段数目
unsigned short bi_hw_segments; 物理合并和DMA remap后不相邻的物理段数目
unsigned int bi_size; 以字节为单位的所需传输的数据大小
unsigned int bi_hw_front_size;
unsigned int bi_hw_back_size;
unsigned int bi_max_vecs; 最大的bvl_vec数
stuct bio_vec *bi_io_vec; 实际的vec列表,struct bio_vec
{ struct page *bv_page; 页指针
unsigned int bv_len; 传输的字节数
unsigned int bv_offset; 偏移位置
}
bio_for_each_segments( bvl, bio, i, start_idx )
bio_end_io_t *bi_end_io;
atomic_t bi_cnt;
void *bi_private;
bio_destructor_t *bi_destructor; destructor
};
int bio_data_dir( struct bio *bio ); 获得数据传输方向
struct page *bio_page( struct bio *bio ); 获得目前的页指针
int bio_offset( struct bio *bio ); 返回操作对应的当前页内的偏移
int bio_cur_sectors( struct bio *bio ); 返回当前bio_vec要传输的扇区数
char *bio_data( struct bio *bio ); 返回数据缓冲区的内核虚拟地址
char *bvec_kmap_irq( struct bio_vec *bvec, unsigned long *flags );
返回一个内核虚拟地址,这个地址用于存取被给定的bio_vec入口指向的数据缓冲区
它也会屏蔽中断并返回一个原子kmap,因此,在unmap前,驱动不应该睡眠.
void bvec_kunmap_irq( char *buffer, unsigned long *flags );
char *bio_kmap_irq( struct bio *bio, unsigned long *flags ); 对bvec_kmap_irq的包装,返回给定bio的当前bio_vec入口的映射
char *__bio_kmap_atomic( struct bio *bio, int i, enum km_type type ); 返回指定bio的第i个缓冲区的虚拟地址
void __bio_kunmap_atomic( char *addr, enum km_type type );
void bio_get( struct bio *bio ); 引用bio
void bio_put( struct bio *bio ); 释放对bio的引用
块设备驱动注册与注销
int register_blkdev( unsigned int major, const char *name ); 在/proc/devices显示
int unregister_blkdev( unsigned int major, const char *name );
xxx_major = register_blkdev( xxx_major, "xxx" );
if ( xxx_major < 0 )
{
printk( KERN_WARNING " xxx: unable to get major number/n " );
return -EBUSY;
}
块设备的模块加载与卸载
加载步骤: 1,分配,初始化请求队列; 绑定请求队列和请求函数.
2,分配,初始化gendisk; 给gendisk的major, fops, queue等成员赋值; 最后添加gendisk.
3,注册块设备驱动
static int __init xxx_init( void )
{
xxx_disks = alloc_disk( 1 ); 分配gendisk
if ( !xxx_disk )
{
goto out;
}
if( register_blkdev( XXX_MAJOR, "xxx" ) ) 块设备注册
{
err = -EIO;
goto out;
}
xxx_queue = blk_alloc_queue( GFP_KERNEL ); 分配"请求队列"
if ( !xxx_queue )
{
goto out_queue;
}
blk_queue_make_request( xxx_queue, &xxx_make_request ); 绑定"制造请求"函数 对应无 队列IO处理
blk_queue_hardsect_size( xxx_queue, xxx_blocksize ); 硬盘扇区尺寸设置
或: xxx_queue = blk_init_queue( xxx_request, xxx_lock ); 对应有队列IO处理
xxx_disks->major = XXX_MAJOR;
xxx_disks->first_minor = 0;
xxx_disks->fops = *xxx_op;
xxx_disks->queue = xxx_queue;
sprintf( xxx_disks->disk_name, "xxx%d", i );
set_capacity( xxx_disks, xxx_size ); gendisk容量
add_disk( xxx_disks ); 添加gendisk
return 0;
out_queue: unregister_blkdev( XXX_MAJOR, "xxx" );
out: put_disk( xxx_disks );
blk_cleanup_queue( xxx_queue );
return -ENOMEM;
}
卸载步骤: 1,清除请求队列
2,删除gendisk和gendisk引用
3,删除块设备引用,注销块设备驱动.
struct void __init xxx_exit( void )
{
if ( bdev )
{
invalidate_bdev( xxx_bdev, 1 );
blkdev_put( xxx_bdev );
}
del_gendisk( xxx_disks );
put_disk( xxx_disks );
blk_cleanup_queue( xxx_queue[i] );
unregister_blkdev( XXX_MAJOR, "xxx" );
}
块设备打开与释放,open,release
static int xxx_open( struct inode *inode, struct file *filp )
{
struct xxx_dev *dev = inode->i_bdev->bd_disk->private_data;
filp->private_data = dev; 赋值file的private_data
...
return 0;
}
块设备的ioctl,块设备层处理了大部分的设备I/O控制.
int xxx_ioctl( struct inode *inode, struct file *filp, unsigned int cmd, unsigned long arg )
{
long size;
struct hd_geometry geo;
struct xx_dev *dev = filp->private_data;
switch ( cmd )
{
case HDIO_GETGEO:
size = dev->size*( hardsect_size/KERNEL_SECTOR_SIZE );
geo.cylinders = ( size & ~0x3f ) >> 6;
geo.heads = 4;
geo.sectors = 16;
geo.start = 4;
if( copt_to_user( (void __user*)arg, &geo, sizeof(geo) ) )
{
return -EFAULT;
}
return 0;
}
return -ENOTTY ;
}
块设备的I/O请求处理
使用请求队列,对于磁盘有用,通过优化读写顺序.但对RAMDISK,FLASH无用.
1,单个请求
void request( reqeust_queue_t *queue ); 当内核要对块设备读写时,调用驱动里的这个函数.
static void xxx_request( request_queue_t *q )
{
struct request *req;
while ( req = evl_next_request(q) != NULL ) 获得第一个request
{
struct xxx_dev *dev = req->rq_disk->private_data;
if ( !blk_fs_request( req ) ) 不是文件系统的request
{
printk( KERL_NOTICE " Skip non-fs request/n" );
end_request( req, 0 ); 通知request失败,0
continue;
}
xxx_transfer( dev, req->sector, req->currnet_nr_sectors, req->buffer, rq_data_dir(req) );
rq_data_dir( req ); 处理这个request
end_request( req, 1 ); 通知完成这个request,1
}
}
static xxx_transfer( struct xxx_dev *dev, unsigned long sector, unsigned long nsect, char *buffer, int write )
{ 完成具体的块设备IO操作
unsigned long offset = sector * KERNEL_SECTOR_SIZE;
unsigned long nbytes = nsect * KERNEL_SECTOR_SIZE;
if ( offset+nbytes > dev->size )
{
printk( KERNER_NOTICE "Beyond-end write (%1d %1d)/n ", offset, nbytes );
return;
}
if ( write )
{
write_dev( offset, buffer, nbytes ); 向设备写nbytes个数据
}
else
{
read_dev( offset, buffer, nbytes ); 从设备读nbytes个数据
}
}
void end_request( struct request *req, int uptodate )
{
if ( !end_that_request_first( req, uptodate, req->hard_cur_sectors ) )
{ 当设备完成一个IO请求的部分或全部传输后,必须通告设备层.使用
int end_that_request_first( struct request *req, int success, int count );
返回0表示count个sectors已传送.
add_disk_randomness( req->rq_disk ); 当disk操作是随机时(机械式),用这个函数,块IO的定时来给系统做随机数池 贡献熵.
blkdev_dequeue_request( req ); 从队列清除req
end_that_request_last( req ); 通知所有正在等待这个req完成的对象,req已完成并回收这个struct
}
}
2,遍历所有请求,遍历请求里每个bio,bio里每个segments.
static void xxx_full_request( request_queue_t *q )
{
struct request *req;
int sectors_xferred;
struct xxx_dev *dev = q->queuedate;
while( (req = elv_next_request(q) ) != NULL )
{
if ( !blk_fs_request(req) )
{
printk( KERN_NOTICE " Skip non-fs request/n" );
end_request( req, 0 );
continiue;
}
sectors_xferred = xxx_xfer_request( dev, req );
if ( !end_that_request_first( req, 1, sectors_xferred ) )
{
blkdev_dequeue_request( req );
end_that_request_last( req );
}
}
}
static int xxx_xfer_request( struct xxx_dev *dev, struct request *req )
{
struct bio *bio;
int nsect = 0;
rq_for_each_bio( bio, req )
{
xxx_xfer_bio( dev, bio );
nsect += bio->bi_size / KERNEL_SECTRO_SIZE;
}
return nsect;
}
static int xxx_xfer_bio( struct xxx_dev *dev, struct bio *bio )
{
int i;
struct bio_vec *bvec;
sector_t sector = bio->bi_sector;
bio_for_each_segment( bvec, bio, i )
{
char *buffer = __bio_kmap_atomic( bio, 1, KM_USER0 );
xxx_transfer( dev, sector, bio_cur_sectors(bio), buffer, bio_data_dir(bio) == WRITE );
sector += bio_cur_sectors( bio );
__bio_kunmap_atomic( bio, KM_USER0 );
}
return 0;
}
不使用请求队列,RAMDISK,SD RAM
static xxx_make_request( request_queue_t *q, struct bio *bio ) q:"请求队列" "制造请求"函数
{
struct xxx_dev *dev = q->queuedata;
int status;
status = xxx_xfer_bio( dev, bio ); 处理bio
bio_endio( bio, bio->bi_size, status ); 通告结束
return 0; 应该是0，如果不为0,bio将再次提交
}
358
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
