1、总线概念

总线是内核与一个或者多个设备之间的通道。在设备模型中，所有的设备都是通过总线连接

2、sysfs

• 作用：
  

  
  一个用于内核对象表述的文件系统
  sysfs是一个基于ramfs的内存文件系统. 描述内核数据结构，属性以及与它们用户空间的链接关系

• sys文件夹内含的顶层文件夹(使用ls -l /sys可以查看)

  1. block/
  2. bus/ ：包含内核中所有总线类型的描述. 每一个总线文件夹下面都有下面两类文件夹
  3. devices/ ：内核中所有注册的设备，内含的设备都是指向sys目录下面devices目录内设备的链接文件
  4. drivers/ ：所有与注册设备相匹配的驱动程序
     总线设备驱动总是会分出设备与驱动，也就是设备、驱动分离分层的概念，在注册的时候总会进行设备与驱动的匹配，内核总线会提供各自的match函数以供此类总线设备驱动调用
  5. class/
  6. devices/ ： 设备树的文件系统表述. 映射了内核的设备结构层次，包含内核所有的注册设备
     
  7. firmware/
  8. net/
  9. fs/ ： 包含一些文件系统的目录.想要表述其属性的文件系统都必须在fs目录下创建自己的层次

3、kobject

每个加载到内核的kobject结构体都具体化为一个sys或者其子目录下的一个文件夹

Kobject

一个基础结构，用于保持设备模型在一起，Kobject最初是用来简单的引用计数的，但是随着时间的发展已经增加了很多的功能

• 对象的引用计数
  当一个内核对象被创建的时候，往往不能够确定这个对象的声明周期，Kobject被用作对象声明周期的跟踪，当对象计数完毕之后且没有内核进行引用，则该对象就可以被删除（正在使用的模块不能够删除应该与此有关）
• sysfs的表示
  在sys下面的每一个对象都对应一个Kobject结构，用来创建其可视化的表示
• 数据结构粘和
  整体来看, 设备模型是一个极端复杂的由多级组成的数据结构, 各级之间有许多连接。kobject 实现这个结构并且保持它在一起
• 热拔插事件的处理
  Kobject负责事件的产生，而事件则负责通知内核用户空间硬件的接入与卸载

Kobject结构体原型(不同版本的内核原型可能不一样)

struct kobject {
    const char      * k_name;               //Kobject静态名字
    char            name[KOBJ_NAME_LEN];    //Kobject名字 
    struct kref     kref;
    struct list_head    entry;              //list_head结构体
    struct kobject      * parent;           //父结构体，往往是指向容纳kobject的kset中的kobject结构体
    struct kset     * kset;                 //kset结构体
    struct kobj_type    * ktype;        //ktype，内包含kobject的relase函数指针
    struct dentry       * dentry;
    wait_queue_head_t   poll;               //等待队列的头部
};

使用Kobject

由于C语言没有继承这一特性，所以需要另一种方法实现，就是在结构体里面嵌入另一个结构体来实现对上一个对象的继承，要从嵌入的结构体找到被嵌入的结构体需要使用container_of宏，这个是与list_head一样的原理，详见list_head结构体详解

• 初始化清零Kobject
  使用memset函数对Kobject结构体进行初始化清零操作，否则会产生意想不到的程序崩溃
• 初始化一个Kobject

void kobject_init(struct kobject *kobj);

• 设置Kobject的名字（必须的，需要用在sysfs的入口）

int kobject_set_name(struct kobject *kobj, const char *fmt, ...);
va_start(args,fmt); //初始化一个char型指针，指向本函数最后一个参数的结尾处并且32字节对齐
(void)((args) = (((char *) &(fmt)) + (((sizeof (fmt)) + (31)) & (~(31)))))

• 设置其他应当设置的 kobject 成员
  ktype, kset, parent.

Kobject引用计数

struct kobject *kobject_get(struct kobject *kobj);  //增加一个计数
void kobject_put(struct kobject *kobj);             //减掉一个计数

当一个Kobject计数为0时，代表此对象已经到达生命周期的尽头，此时就需要一个Kobject的释放函数，而这个释放函数必须存在到其被调用为止，但是又由于这个Kobject释放函数并不能嵌入kobject结构体本身，所以就有了kobj_type这个结构体，此结构体往往可能会在两个地方给出，一个是kobject内部的kobj_type，另一个是包含该kobject的kset给出，已知该kobject的话，可以使用struct kobj_type *get_ktype(struct kobject *kobj);来获取其kobj_type结构体

4、kset

很多情况下，kset被看做是kobj_type的扩展，用来表示被嵌入到同一类型结构的kobject集合。但是kobj_type关注的是特定一个对象，而kset关注的是一整个集合

struct kset {
    struct kobj_type    * ktype;        //内含的kobj_type，用于指示kobject的kobj_type，优先于kobject自身含有的kobj_type
    struct list_head    list;           //用于串联kset的list_head双向循环链表
    spinlock_t      list_lock;  
    struct kobject      kobj;           //内含的kobject
    struct kset_uevent_ops  * uevent_ops;   //
};

增加一个kobject到kset

此时该objetc计数会增加1，因为这是对kobject的一个引用

extern int kobject_register(struct kobject *kobj);
//此函数是kobject_init 和 kobject_add 的结合

从kset删掉一个kobject

void kobject_del(struct kobject *kobj); //或者 
extern void kset_unregister(struct kset * k);
//后者是下述两个函数的结合
extern void kobject_del(struct kobject *);
extern void kobject_put(struct kobject *);

kset提供类似于kobject的接口函数

extern void kset_init(struct kset * k);
extern int __must_check kset_add(struct kset * k);
extern int __must_check kset_register(struct kset * k);
extern void kset_unregister(struct kset * k);

/* 减少一个计数 */
static inline struct kset * kset_get(struct kset * k)
{
    return k ? to_kset(kobject_get(&k->kobj)) : NULL;
}

/* 增加一个计数 */
static inline void kset_put(struct kset * k)
{
    kobject_put(&k->kobj);
}

5、低级sysfs操作

kobjects 的 sysfs 入口一直为目录, 因此一个对 kobject_add 的调用导致在sysfs 中创建一个目录. 常常地, 这个目录包含一个或多个属性

• 分配给 kobject 的名字( 用 kobject_set_name ) 是给 sysfs 目录使用的名字. 因此, 出现在 sysfs 层次的相同部分的 kobjects必须有唯一的名字. 分配给 kobjects 的名字也应当是合理的文件名字: 它们不能包含斜线字符, 不能为空

• sysfs 入口位于对应 kobject 的 parent 指针的目录中. 如果 parent 是 NULL 当 kobject_add 被调用时, 它被设置为嵌在新 kobject 的kset 中的 kobject; 因此, sysfs 层级常常匹配使用 kset 创建的内部层次. 如果 parent 和 kset 都是 NULL, sysfs 目录将在顶级被创建

//每个kobject被创建的时候都会有一个缺省的属性，由kobj_type里面的struct attribute   ** default_attrs;指定
/* struct attribute原型 */
struct attribute {
    const char      * name;
    struct module       * owner;
    mode_t          mode;
};

//属性类别
#define S_IRWXUGO   (S_IRWXU|S_IRWXG|S_IRWXO)
#define S_IALLUGO   (S_ISUID|S_ISGID|S_ISVTX|S_IRWXUGO)
#define S_IRUGO     (S_IRUSR|S_IRGRP|S_IROTH)
#define S_IWUGO     (S_IWUSR|S_IWGRP|S_IWOTH)
#define S_IXUGO     (S_IXUSR|S_IXGRP|S_IXOTH)

/* attrbute只是负责指明属性的类型，而实现这些属性的工作就交给了sysfs_ops */
struct sysfs_ops {
    ssize_t (*show)(struct kobject *, struct attribute *,char *);
    ssize_t (*store)(struct kobject *,struct attribute *,const char *, size_t);
};

• 添加一个属性到kobject

int sysfs_create_file(struct kobject *kobj, struct attribute *attr);

• 删除属性

int sysfs_remove_file(struct kobject *kobj, struct attribute *attr);

• 创建一个符号链接

int sysfs_create_link(struct kobject *kobj, struct kobject *target, char *name);

• 删除一个符号链接

void sysfs_remove_link(struct kobject *kobj, char *name);

6、mybus的编写实现

头文件

#ifndef _MYBUS_H_
#define _MYBUS_H_

#include <linux/device.h>

/* 定义mybus的设备结构体 */
struct mybus_device {
    const char  * name;
    struct device   dev;
    struct mybus_driver *drv;
};
/* 由mybus设备里面的设备结构体找到该mybus，详见list_head结构体注解 */
#define to_mybus_device(_dev) container_of(_dev, struct mybus_device, dev)

/* 定义mybus驱动 */
struct mybus_driver {
    int (*probe)(struct mybus_device *);
    int (*remove)(struct mybus_device *);
    void (*shutdown)(struct mybus_device *);
    int (*suspend)(struct mybus_device *, pm_message_t state);
    int (*resume)(struct mybus_device *);
    struct device_driver driver;
};
/* 同上面的 to_mybus_device */
#define to_mybus_driver(drv) container_of(drv, struct mybus_driver, driver)

extern int register_mybus_device(struct mybus_device *mybusdev);
extern void unregister_mybus_device(struct mybus_device *mybusdev);
extern int register_mybus_driver(struct mybus_driver *mybusdrv);
extern void unregister_mybus_driver(struct mybus_driver *mybusdrv);

#endif /* end _MYBUS_H_ */

C文件

#include <linux/device.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/init.h>
#include <linux/string.h>
#include "/work/testfile/ARM9_Pro/mybus/mybus.h"

/* mybus卸载时候会调用到 */
static void mybus_relase(struct device * dev)
{
    printk("mybus relase \n");
}

/* 总线设备 */
struct device my_bus = {
    .bus_id   = "mybus",
    .release  = mybus_relase
};

/* 设备与设备驱动匹配函数 */
static int mybus_match(struct device * dev, struct device_driver * drv)
{
    struct mybus_device *pdev = to_mybus_device(dev);

    printk("mybus_match is called\n");  //输出打印信息，说明此函数被调用

    return (strncmp(pdev->name, drv->name, BUS_ID_SIZE) == 0);
}

/* mybus总线热拔插事件 */
static int mybus_event(struct device *dev, char **envp, int num_envp,
        char *buffer, int buffer_size)
{
    envp[0] = buffer;
    snprintf(buffer, buffer_size, "LDDBUS_VERSION=%s", mybus_version);

    return 0;
}

/* 定义一个总线结构体 */
struct bus_type mybus_type = {
    .name = "mybus",
    .match = mybus_match,
    .uevent  = mybus_event,
};

/* mybus 的设备与设备驱动操作函数 */
/* mybus 设备相关函数 */
static void mybus_device_release(struct device * dev)
{
    printk("mybus_device relase \n");
}

int register_mybus_device(struct mybus_device *mybusdev)
{
    mybusdev->dev.bus = &mybus_type;    //设置该设备的总线为mybus总线类型
    mybusdev->dev.parent = &my_bus;     //设置该设备的父设备为my_bus设备
    mybusdev->dev.release = mybus_device_release;   //设备释放
    strncpy(mybusdev->dev.bus_id, mybusdev->name, BUS_ID_SIZE); //拷贝名字

    return device_register(&mybusdev->dev); //注册该设备
}

EXPORT_SYMBOL(register_mybus_device);

void unregister_mybus_device(struct mybus_device *mybusdev)
{
    device_unregister(&mybusdev->dev);  //卸载设备
}

EXPORT_SYMBOL(unregister_mybus_device);

/* mybus设备驱动相关的函数 */
static int mybus_driver_probe(struct device *_dev)
{
    struct mybus_driver *drv = to_mybus_driver(_dev->driver);
    struct mybus_device *dev = to_mybus_device(_dev);

    return drv->probe(dev);
}

static int mybus_driver_remove(struct device *_dev)
{
    struct mybus_driver *drv = to_mybus_driver(_dev->driver);
    struct mybus_device *dev = to_mybus_device(_dev);

    return drv->remove(dev);
}

static void mybus_driver_shutdown(struct device *_dev)
{
    struct mybus_driver *drv = to_mybus_driver(_dev->driver);
    struct mybus_device *dev = to_mybus_device(_dev);

    drv->shutdown(dev);
}

static int mybus_driver_suspend(struct device *_dev, pm_message_t state)
{
    struct mybus_driver *drv = to_mybus_driver(_dev->driver);
    struct mybus_device *dev = to_mybus_device(_dev);

    return drv->suspend(dev, state);
}

static int mybus_driver_resume(struct device *_dev)
{
    struct mybus_driver *drv = to_mybus_driver(_dev->driver);
    struct mybus_device *dev = to_mybus_device(_dev);

    return drv->resume(dev);
}

int register_mybus_driver(struct mybus_driver *mybusdrv)
{
    if(mybusdrv->probe)
        mybusdrv->driver.probe = mybus_driver_probe;
    if(mybusdrv->remove)
        mybusdrv->driver.remove = mybus_driver_remove;
    if(mybusdrv->shutdown)
        mybusdrv->driver.shutdown = mybus_driver_shutdown;
    if(mybusdrv->suspend)
        mybusdrv->driver.suspend = mybus_driver_suspend;
    if(mybusdrv->resume)
        mybusdrv->driver.resume = mybus_driver_resume;

    mybusdrv->driver.bus = &mybus_type; //设置设备驱动的总线为mybus总线

    return driver_register(&mybusdrv->driver);  //注册设备驱动
}

EXPORT_SYMBOL(register_mybus_driver);

void unregister_mybus_driver(struct mybus_driver *mybusdrv)
{
    driver_unregister(&mybusdrv->driver);   //卸载设备驱动
}

EXPORT_SYMBOL(unregister_mybus_driver);

/* mybus总线初始化 */
static int mybus_init(void)
{
    int error;

    error = bus_register(&mybus_type);  //注册mybus总线
    if(error){
        bus_unregister(&mybus_type);
        printk("Can‘t register mybus_type bus_type\n");
        return error;
    }
//  此处简化创建，没有使用属性，创建之后会自动被设置为默认属性
//  if(bus_create_file(&mybus_type, &mybus_attribute)){
//      printk("Can‘t create mybus version attribute\n");
//  }

    error = device_register(&my_bus);   //mybus设备注册，所有的从属于mybus总线的设备都会被挂入此设备链表
    if(error){
        device_unregister(&my_bus);
        printk("Can‘t register my_bus device\n");
        return error;
    }

    return 0;
}

/* mybus总线卸载 */
static void mybus_exit(void)
{
    device_unregister(&my_bus);
//  bus_remove_file(&mybus_type, &mybus_attribute);
//  此处简化创建，没有使用属性，创建之后会自动被设置为默认属性
    bus_unregister(&mybus_type);
}

module_init(mybus_init);
module_exit(mybus_exit);
MODULE_LICENSE("GPL");

MODULE_AUTHOR("YellowMax");

8、mybus与驱动的联合测试

led_dev测试程序

#include "/work/testfile/ARM9_Pro/mybus/mybus.h"

static void led_dev_release(struct device * dev)
{
    printk("led_dev relase \n");
}

static struct mybus_device led_dev = {
    .name   =   "by_led",
    .dev    = {
        .release    = led_dev_release,
    },
};

static int led_dev_init(void)
{
    int error;

    error = register_mybus_device(&led_dev);
    if(error){
        printk("register led_dev failed\n");
        unregister_mybus_device(&led_dev);
        return error;
    }
    return 0;
}

static void led_dev_exit(void)
{
    unregister_mybus_device(&led_dev);
}

module_init(led_dev_init);
module_exit(led_dev_exit);
MODULE_LICENSE("GPL");

led_drv测试程序

#include "/work/testfile/ARM9_Pro/mybus/mybus.h"

static int led_drv_probe(struct platform_device *p_dev)
{
    /* 输出打印信息，说明两者成功匹配 */
    printk("Found by_led, Connect success\n");

    return 0;
}

static int led_drv_remove(struct platform_device *p_dev)
{
    /* 输出打印信息，说明成功卸载设备 */
    printk("Found by_led, Remove success\n");

    return 0;
}

static struct mybus_driver led_drv = {
    .probe  = led_drv_probe,
    .remove = led_drv_remove,
    .driver = {
        .name   = "by_led",
    },
};

static int led_drv_init(void)
{
    register_mybus_driver(&led_drv);
    return 0;
}

static void led_drv_exit(void)
{
    unregister_mybus_driver(&led_drv);
}

module_init(led_drv_init);
module_exit(led_drv_exit);
MODULE_LICENSE("GPL");

联合测试

• 装载led_drv.ko查看现象（由于没有注册总线设备，所以会出现函数未定义错误）

insmod led_drv.ko
led_drv: Unknown symbol register_mybus_driver
led_drv: Unknown symbol unregister_mybus_driver
insmod: cannot insert ‘led_drv.ko‘: Unknown symbol in module (-1): No such file or directory

• 装载mybus.ko并且查看/sys/bus/

insmod mybus.ko
ls -l /sys/bus/
drwxr-xr-x    4 0        0               0 Jan  1 00:01 mybus

• 查看设备

ls -l /sys/devices/
drwxr-xr-x    3 0        0               0 Jan  1 00:01 mybus

• 再次装载led_drv.ko并查看mybus里面的驱动

insmod led_drv.ko
ls -l /sys/bus/mybus/drivers
drwxr-xr-x    2 0        0               0 Jan  1 00:12 by_led

• 装载led_dev.ko

insmod led_dev.ko 
mybus_match is called       //调用到了mybus.c里面的相关match函数
Found by_led, Connect success   //调用到led_drv.c里面的probe相关函数

• 装载其他模块

insmod led_drv1.ko 
insmod led_drv2.ko 
insmod led_dev2.ko 
mybus_match is called
mybus_match is called
mybus_match is called
Found by_led2, Connect success

由此可见，mybus.c里面的match相关函数会被内核不断地调用，直到找到匹配的设备或者驱动（测试函数同上，只不过修改一下设备以及驱动名字）。我装载了3个驱动，一共找了三次，基本可以说明这些设备是挂载在mybus总线设备上面的，找的时候直接去mybus总线找，

insmod led_dev1.ko 
mybus_match is called
mybus_match is called
Found by_led1, Connect success

• 全部装载完毕并且查看相关的设备以及设备驱动

ls -l /sys/bus/mybus/drivers
drwxr-xr-x    2 0        0               0 Jan  1 00:12 by_led
drwxr-xr-x    2 0        0               0 Jan  1 00:13 by_led1
drwxr-xr-x    2 0        0               0 Jan  1 00:13 by_led2
ls -l /sys/bus/mybus/devices/
lrwxrwxrwx    1 0        0               0 Jan  1 00:15 by_led -> ../../../devices/mybus/by_led
lrwxrwxrwx    1 0        0               0 Jan  1 00:15 by_led1 -> ../../../devices/mybus/by_led1
lrwxrwxrwx    1 0        0               0 Jan  1 00:15 by_led2 -> ../../../devices/mybus/by_led2

• 尝试移除mybus

rmmod mybus 
rmmod: mybus: Resource temporarily unavailable

rmmod led_dev1 
Found by_led, Remove success
mybus_device relase
rmmod led_dev 
Found by_led, Remove success
mybus_device relase 
rmmod led_dev2
Found by_led, Remove success
mybus_device relase 
rmmod led_drv
rmmod led_drv1
rmmod led_drv2

• 再次尝试移除mybus，调用到了mybus.c里面的static void mybus_relase(struct device * dev)函数，mybus设备引用计数达到0

rmmod mybus 
mybus relase

9、分析mybus过程

/* 初始化注册一个bus总线 */
int bus_register(struct bus_type * bus)
    retval = kobject_set_name(&bus->subsys.kobj, "%s", bus->name);  //将总线对应为mybus子系统的Kobject结构
    /* 将Kobject放入一个kset容器，并且注册 */
    subsys_set_kset(bus, bus_subsys);
    retval = subsystem_register(&bus->subsys);

    /* 设置一个名字为devices的Kobject，然后将其父结构指向上面构建的mybus的Kobject */
    kobject_set_name(&bus->devices.kobj, "devices");
    bus->devices.kobj.parent = &bus->subsys.kobj;

    /* 初始化bus总线的device链表与driver链表，device链表添加get（增加一个设备引用计数），put（减少一个设备引用计数） 
     * 之后在此bus总线里面加入设备以及驱动的时候就可以通过该bus总线的设备链与设备驱动链进行查找了 
     */
    klist_init(&bus->klist_devices, klist_devices_get, klist_devices_put);
    klist_init(&bus->klist_drivers, NULL, NULL);

/* 提供该bus总线的设备注册 */
int register_mybus_device(struct mybus_device *mybusdev)
    /* 结构体的填充 */
    mybusdev->dev.bus = &mybus_type;    //设置该设备的总线为mybus总线类型
    mybusdev->dev.parent = &my_bus;     //设置该设备的父设备为my_bus设备
    mybusdev->dev.release = mybus_device_release;   //设备释放
    strncpy(mybusdev->dev.bus_id, mybusdev->name, BUS_ID_SIZE); //拷贝名字

    return device_register(&mybusdev->dev); //注册该设备

/* 提供该bus总线的设备驱动注册 */   
int register_mybus_driver(struct mybus_driver *mybusdrv)
    if(mybusdrv->probe)
        mybusdrv->driver.probe = mybus_driver_probe;
    if(mybusdrv->remove)
        mybusdrv->driver.remove = mybus_driver_remove;

    //省略若干

    mybusdrv->driver.bus = &mybus_type; //设置设备驱动的总线为mybus总线

    return driver_register(&mybusdrv->driver);  //注册设备驱动

10、总线设备以及总线设备驱动的注册

分别由device_register与driver_register实际完成注册
在两者的函数里面都会有试图获得该注册对象的bus的语句，如果获得成功的话，不仅在系统顶层的sys/devices里面创建对象Kobject，而且在对应的bus里面也创建Kobject用来计数以及以文件形式显示出来设备。同一个被注册对象可能会被不同的链表链接，在任意一个链表里面都可以找到该对象。就比如一个总线设备，在其bus总线的设备列表里面可以找得到，在系统的devices链表里面也可以找得到