大多数基本的驱动操作涉及到内核的3个重要数据结构：file_operations,file 和inode。
我们已经拥有一些设备号，但是如何将其与驱动操作连在一起呢？file_operations结构就是这个桥梁，这个结构体定义在<Linux/fs.h>中，它是一群函数的指针集合，每个所打开的文件都存在一个f_op指针指向file_operations结构体，里面的操作大部分主要完成系统调用，如open,read等。我们可以将file看成对象,对它操作的操作看成是方法,使用面向对象程序设计（object-orientedprogramming）这个术语表征某一对象的行为声明会作用于它自身。后面将会看到更多这种情况。
一般来说，一个指向file_operations结构的指针称为fops。这个结构体里面的每个域必须指向驱动中的某些函数以完成一些特定的操作，或者赋予NULL值表示没有支持的操作。当被赋予NULL时，内核的具体行为对每个函数来说都不尽相同。
1 首先我们来看看file_operations结构吧
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
int (*readdir) (struct file *, void *, filldir_t);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
int (*ioctl) (struct inode *, struct file *, unsigned int, unsigned long);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, struct dentry *, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
};
看到上面一大坨是不是有点晕呢？其实我们只关注一些在写驱动程序时需要用到的相关项就行了。
当你浏览file_operations结构中的各种操作方法时，我们可以发现有许多的参数含有”__user”，可以说这是一种规范吧，用以表明这是用户层空间的指针，在内核中我们不能直接对它进行引用。
先来看第一个域吧：struct module *owner;
这个域并非某种操作方式，它只是一个指向拥有此结构体的模块的指针，它主要是用来防止模块在使用的过程中被卸载。在大多数情况下，这个域一般都被初始化成THIS_MODULE,即 .owner = THIS_MODULE;
loff_t (*llseek)(struct file *, loff_t, int);
此方法是用来改变文件中的读写位置，函数正确返回的是一个新的位置。第二个参数：loff_t是一个“long”型的偏移量，一般是64位。函数出错时返回的是负值。
ssize_t (*read)(struct file *, char _ _user *, size_t, loff_t *);
此方法用于存储来自设备的数据，当返回值为非负值时表示成功读取的字节数，返回值一般是有符号整型的数据类型。
ssize_t(*aio_read)(struct kiocb *, char _ _user *, size_t, loff_t);
默认情况下为异步读取– 在函数返回之前，可能读操作并未全部完成。如果此方法为NULL型，所有的操作方式都由read（同步）代替。
ssize_t (*write)(struct file *, const char _ _user *, size_t, loff_t *);
主要是给设备发数据，如果函数返回值为非负整数，表示成功写入的字节数。
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 *);
这三个系统调用（poll, epoll，select）最终都用调用底层的poll方法 ，换句话说，这三个系统调用最终在驱动里都是执行poll方法。他们是用于查询是否对阻塞的文件描述符进行读写操作。Poll方法将返回一位隐码标志位（mask）来指明是否有可用的非阻塞读或写操作，如果有，则给内核提供一些信息，这些信息用于使相应的进程进入休眠直到IO可用。如果驱动中给此域赋NULL,此时设备无阻塞发生时依旧都是可读、可写的。
int (*ioctl)(struct inode *, struct file *, unsigned int, unsigned long);
ioctl系统调用提供了一种解决设备特殊命令的方法，如格式化磁盘操作，这些既不是读也不是写操作。此外，许多ioctl命令是由内核组织的而非从ftops表中引用，如果设备没有提供ioctl方法，此系统调用将返回错误。
int (*mmap) (structfile *, struct vm_area_struct *);
mmap用于将设备存储空间与进程的地址空间进行映射，如果此域为NULL,mmap系统调用将返回-ENODEV.
int (*open) (structinode *, struct file *);
open总是在设备文件上执行的第一步操作。这个比较简单，不多说啦。。
int (*flush)(struct file *);
当进程关闭设备的文件描述时，flush操作就被触发，它将对设备执行一些非常重要的操作。不能将其与应用层上的fsync操作混淆。在目前，flush用在非常少的驱动上，如SCSI磁道驱动就使用它来确保在设备关闭之前所有的数据都被写入硬盘，如果flush为NULL,那么内核会忽略用户应用层的请求。
int (*release)(struct inode *, struct file *);
当file结构体被释放时，此操作被触发。与open一样，它也可以为NULL.
int (*fsync)(struct file *, struct dentry *, int);
此操作用于通知设备其FASYNC标志位发生变化了，此方法在异步通知得到了应用，如果此域为NULL,驱动就不支持异步通知操作了。
int (*lock) (structfile *, 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 *);
此方法主要完成分散或聚集式的read/write操作，应用程序偶尔需要在多个内存区域中做一些简单的读或写操作，这些系统调用可以使应用程序不需要在数据上做一些额外的工作就可以实现在多个内存中做简单的读写。如果为NULL,那么调用的就是read/write了。
ssize_t (*sendpage)(struct file *, struct page *, int, size_t, loff_t *, int);
ssize_t(*sendfile)(struct file *, loff_t *, size_t, read_actor_t, void *);
设备驱动一般不涉及此项
int(*check_flags)(int)
此方法允许模块检查传递给fcntl(F_SETFL…)的标志量。
----------------------------------------------------------------------------
2file 文件结构
在设备驱动中，这也是个非常重要的数据结构，必须要注意一点，这里的file与用户空间程序中的FILE指针是不同的，用户空间FILE是定义在C库中，从来不会出现在内核中。而struct file，却是内核当中的数据结构，因此，它也不会出现在用户层程序中。
file结构体指示一个已经打开的文件，其实系统中的每个打开的文件在内核中都有一个相应的structfile结构体，直至文件被关闭。如果文件被关系，内核就会释放相应的数据结构。
在内核源码中， struct file 要么表示为file，或者为filp(意指“file pointer”), 注意区分一点，file指的是struct file本身，而filp是指向这个结构体的指针。
fmode_t f_mode;
此文件模式通过FMODE_READ, FMODE_WRITE识别了文件为可读的，可写的，或者是二者。在open或ioctl函数中可能需要检查此域以确认文件的读/写权限，你不必直接去检测读或写权限，因为在进行open/ioctl等操作时内核本身就需要对其权限进行检测。
loff_t f_pos;
当前读写文件的位置。为64位。如果想知道当前文件当前位置在哪，驱动可以读取这个值而不会改变其位置。对read,write来说，当其接收到一个loff_t型指针作为其最后一个参数时，他们的读写操作便作更新文件的位置，而不需要直接执行filp ->f_pos操作。而llseek方法的目的就是用于改变文件的位置。
unsigned intf_flags;
文件标志，如O_RDONLY, O_NONBLOCK以及O_SYNC。在驱动中还可以检查O_NONBLOCK标志查看是否有非阻塞请求。其它的标志较少使用。特别地注意的是，读写权限的检查是使用f_mode而不是f_flog。所有的标量定义在头文件<linux/fcntl.h>中
structfile_operations *f_op;
与文件相关的各种操作。当文件需要迅速进行各种操作时，内核分配这个指针作为它实现文件打开，读，写等功能的一部分。filp->f_op 其值从未被内核保存作为下次的引用，即你可以改变与文件相关的各种操作，这种方式效率非常高。
void *private_data;
在驱动调用open方法之前，open系统调用设置此指针为NULL值。你可以很*的将其做为你自己需要的一些数据域或者不管它，如，你可以将其指向一个分配好的数据，但是你必须记得在file struct被内核销毁之前在release方法中释放这些数据的内存空间。private_data用于在系统调用期间保存各种状态信息是非常有用的。
3 inode结构
内核使用inode结构体在内核内部表示一个文件。因此，它与表示一个已经打开的文件描述符的结构体(即file 文件结构)是不同的，我们可以使用多个file 文件结构表示同一个文件的多个文件描述符，但此时，所有的这些file文件结构全部都必须只能指向一个inode结构体。
inode结构体包含了一大堆文件相关的信息，但是就针对驱动代码来说，我们只要关心其中的两个域即可：
(1) dev_t i_rdev;
表示设备文件的结点，这个域实际上包含了设备号。
(2)struct cdev *i_cdev;
struct cdev是内核的一个内部结构，它是用来表示字符设备的，当inode结点指向一个字符设备文件时，此域为一个指向inode结构的指针。
此外，内核也提供了两个宏可以从inode结点中获取主次设备号，宏的原型如下：
unsigned int iminor(struct inode *inode);
unsigned int imajor(struct inode *inode);
Linux设备驱动模型有几个基本数据结构模型：kobject，kset，subsystem
kobject：这是设备驱动模型的基础，就想是一座楼的地板砖和砖头。sysfs是它的子子孙孙，父父爷爷撑起来的
struct kobject
{
const char *name; //显示在sysfs中的名称
struct list_head entry; //下一个kobject结构
struct kobject *parent; //指向父kobject结构体，如果存在
struct kset *kset; //指向kset集合
struct kobj_type *ktype; //指向kobject类型描述符
struct sysfs_dirent *sd; //对应sysfs的文件目录
struct kref kref; //kobject引用计数
unsigned int state_initialized:1; //是否初始化
unsigned int state_in_sysfs:1; //是否加入sysfs
unsigned int state_add_uevent_sent:1; //是否支持热插
unsigned int state_remove_uevent_sent:1; //是否支持热拔
}
void kobject_init(struct kobject *kobj,struct kobj_type *ktype)
{
char * err_str;
if(!kobj)
{
err_str = "invalid kobject pointer!"
goto error;
}
if(!ktype)
{
err_str = "must have a ktype to be initialized properly!\n";
goto error;
}
if(kobj->state_initialized)
{
printk(KERN_ERR"kobject (%p): tried to init an initialized"
"object ,something is seriously wrong.\n",kobj);
dump_stack();
}
kobject_init_internal(kobj); //初始化kobject的内部成员
kobj->ktype = ktype ; //为kobject绑定一个ktype属性
return ;
error:
printk(KERN_ERR"kobject (%p) : %s\n",kobj,err_str);
dump_stack();
}
static void kobject_init_internal(struct koject *kobj)
{
if(!kobj)
return ;
kref_init(&kobj->kerf);
INIT_LIST_HEAD(&kobj->entry);
kobj->state_in_sysfs = 0;
kobj->state_add_uevent_sent = 0;
kobj->state_remove_uevent_sent = 0;
kobj->state_initialized = 1;
}
内核接口:
kobject_init(); 始化kobject
kobject_get(); 增加kobject引用计数
kobject_put(); 减少kobject引用计数，计数为零时，调用kobject_release（）释放，它在kobj_type里面
kobject_set_name(); 设置名字
kobject_rename(); 重命名
kobject_add() 添加
每个kobject都会有一个属性kobj_type
struct kobj_type
{
void (*release)(struct kobject *kobj); //释放kobject和其他占用资源的函数
struct sysfs_ops *sysfs_ops; //操作属性的方法
struct attribute **default_attrs; //属性数组
};
struct attribute
{
const char *name; //属性的名称
struct module *owner; //只用拥有该属性的模块，已经不常使用
mode_t mode; //属性读写权限
};
struct sysfs_ops
{
ssize_t (*show)(struct kobject *,struct attribute *,char *); //读属性操作函数
ssize_t (*store)(struct kobject *,struct attribute *,const char *,size_t); //写属性操作函数
};
struct kobject *kobject_get(struct kobject *kobj)
{
if(kobj)
kref_get(&kobj->kerf);
return kobj;
}
void kobject_put(struct kobject *kobj)
{
if(kobj)
{
if(!kobj->state_initialized)
WARN(1,KERN_WARNING"kobject: ‘%s' (%p):is not initialized,yet kobject_put() is being called.\n",kobject_name(kobj),kobj);
kref_put(&kobj->kref,kobject_release);
}
}
通常kobject类型的default_attr成员定义了kobjet拥有的所有默认属性。但是特殊情况下，可以添加一些默认的属性：
添加属性文件：
int sysfs_create_file(struct kobject *kobj,const struct attribute *attr);
删除属性文件：
void sysfs_remove_file(struct kobject *kobj , const struct attribute *attr);
struct kset
{
struct list_head list; //连接所包含的kobject对象的链表首地址
spinlock_t list_lock; //维护list链表的自旋锁
struct kobject kobj; //内嵌kobject，说明kset本身也是一个目录
struct kset_uevent_ops *uevent_ops; //热插拔事件
};
struct kset_uevent_ops
{
int (*filter)(struct kset *kset,struct kobject *kobj);
const char *(*name)(struct kset *kset,struct kobject *kobj);
int (*uevent)(struct kset *kset,struct kobject *kobj,struct kobj_uevent_ent *env);
};
kset和kobject关系：
1,kset集合包含了属于其的kobject结构体，kset.list链表用来 连接第一个和最后一个kobject对象。第一个kobject使用entry连接kset集合和第二个kobject对象。第二个kobject对象使用entry连接第一个kobject对象和第三个kobject对象，依次类推，最终形成了一个kobject对象的链表
2，所有的kobject结构的parent指针指向kset包含的kobject对象，构成一个父子层次关系
3，kobject的所有kset指针指向包含它的kset集合，所以通过kobject对象很容易就能找到kset集合
4，kobject的kobj_type指针指向自身的kobj_type，每一个kobject都有一个单独的kobj_type结构。另外在kset集合中也有一个kobject结构体，该结构体的XXX也指向一个kobj_type结构体。可知，kobj_type中定义了一组属性和操作属性的方法。这里注意：kset中kobj_type的优先级要高于kobject对象中的kobj_type的优先级。如果两个kobj_type都存在，那么优先调用kset中的函数。如果kset中的kobj_type为空，才调用各个kobject结构体本身对应的kobj_type中的函数
5，kset中的kobj也负责对kset的引用计数
kset操作
void kset_init(struct kset *k) //初始化
{
kobject_init_internal(&k->kobj);
INIT_LIST_HEAD(&k->list);
spin_lock_init(&k->list_lock);
}
int kset_register(struct kset *k); //注册函数
void kset_unregister(struct kset *k); //注销函数
static inline struct kset *kset_get(struct kset *k);
static inline void kset_put(struct kset *k);
设备驱动模型的三大组件
总线：
struct bus_type
{
const char *name;
struct bus_attribute *bus_attrs;
struct device_attribute *dev_attrs;
struct driver_attribute *drv_attrs;
int (*match)(struct device *dev,struct device_driver *drv);
int (*uevent)(struct device *dev,struct kobj_uevent_env *env);
int (*probe)(struct device *dev);
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);
int (*suspend)(struct device *dev,pm_message_t state);
int (*suspend_late)(struct device *dev,pm_message_t state);
int (*resume_early)(struct device *dev);
struct dev_pm_ops *pm;
struct bus_type_private *p;
};
struct bus_type_private
{
struct kset subsys; //代表该bus子系统，里面的kobj是该bus的主kobj，也就是最顶层
struct kset *drivers_kset; //挂载到该总线上的所有驱动集合
struct kset * devices_kset; //挂载到该总线上的所有设备集合
struct klist klist_devices; //所有的设备列表
struct klist klist_drivers; //所有的驱动程序列表
struct block_notifier_head bus_notifier;
unsigned int drivers_autoprobe:1; //设置是否在驱动注册是，自动弹出设备
struct bus_type *bus; //回指向包含自己的总线
};
int bus_register(struct bus_type *bus);
void bus_unregister(struct bus_type *bus);
struct bus_attribute
{
struct attribute attr;
ssize_t (*show)(struct bus_type *bus,char *buf);
ssize_t (*store)（struct bus_type *bus,const char *buf,size_t count);
};
int bus_create_file(struct bus_type *bus,struct bus_attribute *attr);
void bus_remove_file(struct bus_type *bus,struct bus_attribute *attr);
设备：
struct device
{
struct klist klist_children; //连接子设备的链表
struct device *parent; //指向父设备的指针
struct kobject kobj; //内嵌的kobject
char bus_id[BUS_ID_SIZE]; //连接到总线上的位置
unsigned uevent_supress:1; //是否支持热插拔事件
const char *init_name; //设备的初始化名字
struct device_type *type; //设备相关的特殊处理函数
struct bus_type *bus; //指向连接的总线指针
struct device_driver *driver; //指向该设备的驱动程序
void *driver_data; //指向驱动程序私有数据的指针
struct dev_pm_info power; //电源管理信息
dev_t devt; //设备号
struct class *class; //指向设备所属类
struct attribute_group **groups; //设备的组属性
void (*release)(struct device *dev); //释放设备描述符的回调函数
...
};
int device_register(struct device *dev);
void device_unregister(struct device *dev);
struct device_attribute
{
struct attribute attr;
ssize_t (*show)(struct device *dev,struct device_attribute *attr,char *buf);
ssize_t (*store)(struct device *dev,struct device_attribute *attr,const char *buf,size_t count);
};
int device_create_file(struct device *device,struct device_attribute);
void device_remove_file(struct device *dev,struct device_attribute *attr);
驱动：
struct device_driver
{
const char *name; //设备驱动名字
struct bus_type *bus; //指向驱动属于的总线，总线上有很多设备
struct module *owner; //设备驱动自身模块
const char *mod_name; //设备驱动名字
int (*probe)(struct device *dev); /探测函数
int (*remove)(struct device *dev);
void (*shutdown)(struct device *dev);
int (*suspend)(struct device *dev,pm_message_t state);
int (*resume)(struct device *dev);
struct attribute_group **group;
struct dev_pm_ops *pm;
struct driver_private *p;
};
struct driver_private
{
struct kobject kobj; //内嵌kobject结构，用来构建设备驱动程序模型
struct klist klist_devices; //该驱动支持的所有设备链表
struct klist_node knode_bus; //该驱动所属总线
struct module_kobject *mkobj; //驱动的模块
struct device_driver *driver; //指向驱动本身
};
int driver_register(struct device_driver *drv);
void driver_unregister(struct device_driver *drv);
struct driver_attribute
{
struct attribute attr;
ssize_t (*show)(struct device_driver *driver ,char *buf);
ssize_t (*store)(struct device_driver*driver,const char *buf,size_t count);
};
int driver_create_file(struct device_driver *drv,struct driver_attribute *attr);
void driver_remove_file(struct device_driver *drv,struct driver_attribute *attr);
下面是好的一些说明文档：