！Warning：请确保能够访问图床Imgur，以正常显示图片
源码基线：linux-4.0-rc1 & OpenWrt 12.09 branch (Attitude Adjustment)
硬件：Atheros AR9331
1 设备模型概述
设备模型主要完成以下工作：
- 设备分类，以分层的架构对设备进行描述，隐藏设备内部的连接细节，对外清晰地展示可用的设备。
- 创建和管理设备的生命周期。
- 通过sysfs虚拟文件系统，向用户空间提供对设备的读写操作，获取设备的信息、改变设备的运行状态。
设备模型的结构组成：
1.总线。
所有的设备都通过总线相连，包括内部的虚拟总线。在内核中，用struct bus_type结构体来表示总线。
struct bus_type {
const char * name;
struct kset drivers;
struct kset devices;
}
-
name是总线的名字。 -
kset drivers与kset devices，分别代表了总线的驱动程序及插入总线的所有设备集合。
2.设备。
每个设备实例用struct device结构体来表示。
struct device {
struct device *parent;
struct kobject kobj;
char bus_id[BUS_ID_SIZE];
struct bus_type * bus;
struct device_driver *driver;
}
- parent指向设备的所属父设备，通常是某种总线。
- kobj表示本设备对象。
- bus_id是总线上标识设备的ID信息，通常由字符串"<域编号>:<总线编号>:<设备编号>:<功能编号>"定义
-
bus标识了设备连接在哪个总线上。 -
driver管理设备的驱动程序。
3.驱动程序。
设备驱动程序设备模型可以跟踪所有注册的设备，驱动程序为设备提供服务，完成设备的工作。设备的驱动程序由结构体struct device_driver定义。
struct device_driver {
const char * name;
struct bus_type * bus;
struct kobject kobj;
struct klist klist_devices;
}
-
name是驱动程序的名字。 -
bus是指驱动程序所操作的总线类型。 -
kobj表示驱动程序服务的设备对象。 -
klist_devices是驱动程序当前能操作的设备链表。
主要数据结构
-
struct net_device：表示网络设备实例，存储了网络设备的一些关键信息： - 设备名称。
- 设备mac地址。由软件随机生成。
- 广播地址。
- 以太网类型、帧长度、帧头长度、mtu大小。
- 设备模型对象。
-
struct net_bridge：网桥的默认vid，默认优先级，生成树使能状态。 -
struct net_port_vlans：网桥管理的所有vlan列表。 -
struct net_bridge_fdb_entry：网桥管理的所有mac转发表。 -
netdev_queue,netdev_rx_queue：网桥的收发包队列。 -
struct net：linux网络命名空间
struct net_port_vlans {
u16 port_idx;
u16 pvid;
union {
struct net_bridge_port *port;
struct net_bridge *br; /* vlan所属网桥，即vlan对哪个网桥生效 */
} parent;
struct rcu_head rcu;
unsigned long vlan_bitmap[BR_VLAN_BITMAP_LEN]; /* 已创建的vlan列表 */
unsigned long untagged_bitmap[BR_VLAN_BITMAP_LEN]; /* 哪些vlan出口时
去掉tag */
u16 num_vlans;
};
struct net_bridge_fdb_entry
{
struct hlist_node hlist;
struct net_bridge_port *dst; /* mac地址绑定的端口 */
unsigned long updated;
unsigned long used;
mac_addr addr; /* mac地址 */
__u16 vlan_id;
unsigned char is_local:1, /* 是否本机mac地址 */
is_static:1, /* 是否静态mac地址 */
added_by_user:1,
added_by_external_learn:1;
struct rcu_head rcu;
};
struct net_bridge
{
spinlock_t lock;
struct list_head port_list; /* 网桥的虚拟端口struct net_bridge_port */
struct net_device *dev; /* 网桥设备br0信息 */
struct pcpu_sw_netstats __percpu *stats;
spinlock_t hash_lock;
struct hlist_head hash[BR_HASH_SIZE]; /* mac地址hash表，
每个mac地址由struct net_bridge_fdb_entry表示 */
}
struct net_device {
char name[IFNAMSIZ]; /* 设备名称 */
struct hlist_node name_hlist; /* 设备名称链表 */
struct netdev_hw_addr_list dev_addrs; /* 设备mac地址 */
struct hlist_node index_hlist; /* ifindex链表 */
unsigned long mem_end; /* 设备共享内存的起始地址 */
unsigned long mem_start; /* 设备共享内存的结束地址 */
unsigned long base_addr; /* 网络设备I/O基地址 */
int irq; /* 设备使用的中断号 */
const struct net_device_ops *netdev_ops;
const struct ethtool_ops *ethtool_ops;
const struct forwarding_accel_ops *fwd_ops;
}
主要链表结构
主要使用的链表数据结构是hlist_head与hlist_node，其工作原理与list_head类似。
struct hlist_head {
struct hlist_node *first;
};
struct hlist_node {
struct hlist_node *next, **pprev;
};
通过hlist_add_head_rcu(struct hlist_node *n, struct hlist_head *h)函数，可以把新节点添加到链表中。
-
空节点
-
添加第一个节点
-
添加第二个节点
2 platform总线
struct kobject与kset结构体
kobject与kset是组成设备模型的基本结构，为来表示设备模型的设备实例与设备层次关系。这两个结构体作为面向对象概念的基类，嵌套在其他结构体里使用。在sysfs中显示的每一个实例，都对应一个kobject。
/* 设备模型的基本结构。
* 在sysfs中显示的每一个对象，都对应一个kobject，它被用来与内核交互并创建它的可见表述。
* 内核用kobject结构将各个对象连接起来组成一个分层的结构体系 */
struct kobject {
const char *name;
struct kref kref; /* 对象的引用计数。一个内核对象被创建时，需要知道对象存活
的时间，跟踪生命周期的一个方法是使用引用计数，当内核中没有该对象的引用
时，表示对象的生命周期结束，可以被删除 */
struct list_head entry; /* 连接到kset建立层次结构 */
struct kobject * parent; /* parent保存了分层结构中上一层节点kobject结构
的指针。比如一个kobject结构表示了一个USB设备，它的parent指针可能指向
了表示USB集线器的对象，而USB设备是插在USB集线器上的。parent指针最重
要的用途是在sysfs分层结构中定位对象 */
struct kset * kset; /* 一个kset是嵌入相同类型结构的kobject集合。每个kset
内部，包含了自己的kobject。kset总是在sysfs中出现，一旦设置了kset并
把它添加到系统中，将在sysfs中创建一个目录。kobject不必在sysfs中表示，
但kset中每一个kobject成员都将在sysfs中得到表述 */
struct kobj_type * ktype; /* 属性结构。kset中也有一个ktype，其使用优先于
kobject的此处ktype，因此在典型应用中，kobject中的ktype成员被设置
为NULL */
struct sysfs_dirent * sd; /* 指向sysfs下以kobj.name所命名生成的目录 */
};
struct kset {
struct kobj_type *ktype;
struct list_head list;
spinlock_t list_lock;
struct kobject kobj;
struct kset_uevent_ops *uevent_ops;
};
假设有个总线X-bus，以及3个设备驱动A-driver、B-driver、C-driver，且这3个设备都属于同一类X-bus总线。那么kobject与kset在描述设备模型时，通常这样使用。在X-bus的描述结构体中包含kset结构体作为同一类型设备的集合；在描述设备驱动A、B、C的driver结构体中包含kset指针，指向所属的类型集合。每个driver都有一个kobject来表示驱动实例自身，并把所有集合按照加入的先后顺序通过list链表(kset.list与kobject.entry)连接起来。
注册platform总线
函数入口driver_init()
void __init driver_init(void)
{
devices_init();
buses_init();
platform_bus_init();
}
devices_init()
devices_init()创建sysfs模型如下：
/sys
├── dev
│ ├── block
│ └── char
└── devices
```c
struct kset *devices_kset; /* /sys/devices/ */
static struct kobject *dev_kobj;
struct kobject *sysfs_dev_char_kobj;
struct kobject *sysfs_dev_block_kobj;
int __init devices_init(void)
{
devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL);
dev_kobj = kobject_create_and_add("dev", NULL);
sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj);
sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj);
}
kset_create_and_add()
/* 动态创建kset结构体，在sysfs中创建以@name命名的目录，如果kset->kobj.ktype有属性值，
则在目录下创建以属性名命名的文件 */
struct kset *kset_create_and_add(const char *name,
const struct kset_uevent_ops *uevent_ops,
struct kobject *parent_kobj)
{
struct kset *kset;
kset = kset_create(name, uevent_ops, parent_kobj); /* 动态创建kset结构体 */
kset_register(kset); /* 初始化kset，并加入到sysfs */
}
/* 动态创建kset结构体 */
static struct kset *kset_create(const char *name,
const struct kset_uevent_ops *uevent_ops,
struct kobject *parent_kobj)
{
struct kset *kset;
int retval;
kset = kzalloc(sizeof(*kset), GFP_KERNEL);
kobject_set_name(&kset->kobj, "%s", name);
kset->uevent_ops = uevent_ops;
kset->kobj.parent = parent_kobj;
kset->kobj.ktype = &kset_ktype;
kset->kobj.kset = NULL;
return kset;
}
/* 初始化kset，并加入到sysfs */
int kset_register(struct kset * k)
{
kset_init(k);
kobject_add_internal(&k->kobj);
kobject_uevent(&k->kobj, KOBJ_ADD);
}
void kset_init(struct kset * k)
{
kobject_init_internal(&k->kobj);
INIT_LIST_HEAD(&k->list);
spin_lock_init(&k->list_lock);
}
static void kobject_init_internal(struct kobject *kobj)
{
kref_init(&kobj->kref); /* 初始化kobject的引用计数为1 */
INIT_LIST_HEAD(&kobj->entry); /* 初始化entry链表 */
kobj->state_in_sysfs = 0; /* 设备注册标志，0表示未注册 */
kobj->state_add_uevent_sent = 0;
kobj->state_remove_uevent_sent = 0;
kobj->state_initialized = 1;
}
/* kobject_add_internal()在sysfs下建立以kobj.name命名的目录 */
static int kobject_add_internal(struct kobject *kobj)
{
struct kobject *parent;
parent = kobject_get(kobj->parent);
/* join kset if set, use it as parent if we do not already have one */
if (kobj->kset) {
if (!parent)
parent = kobject_get(&kobj->kset->kobj);
kobj_kset_join(kobj);
kobj->parent = parent;
}
create_dir(kobj);
kobj->state_in_sysfs = 1; /* 标记设备已注册 */
}
/* 创建kobject对象的目录及属性文件 */
static int create_dir(struct kobject *kobj)
{
const struct kobj_ns_type_operations *ops;
sysfs_create_dir_ns(kobj, kobject_namespace(kobj)); /* 创建目录 */
populate_dir(kobj); /* 创建属性文件 */
sysfs_get(kobj->sd);
ops = kobj_child_ns_ops(kobj);
if (ops) {
sysfs_enable_ns(kobj->sd);
}
}
/* 以kobj.name命名，在sysfs下创建一个目录 */
int sysfs_create_dir_ns(struct kobject *kobj, const void *ns)
{
struct kernfs_node *parent, *kn;
/* 指定创建的kobj目录所属的的父目录，默认为sysfs根目录 */
if (kobj->parent)
parent = kobj->parent->sd;
else
parent = sysfs_root_kn;
/* 在parent目录下，创建以kobj.name命名的目录 */
kn = kernfs_create_dir_ns(parent, kobject_name(kobj),
S_IRWXU | S_IRUGO | S_IXUGO, kobj, ns);
kobj->sd = kn;
}
/* 对象可能是带有属性的，在kobject目录下创建以属性名命名的文件 */
static int populate_dir(struct kobject *kobj)
{
struct kobj_type *t = get_ktype(kobj);
struct attribute *attr;
int i;
if (t && t->default_attrs) {
for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
sysfs_create_file(kobj, attr);
}
}
}
devices_kset = kset_create_and_add("devices", &device_uevent_ops, NULL)创建的模型：
kobject_create_and_add()
/* 动态创建一个kobject对象，并且加入到sysfs */
struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
{
struct kobject *kobj;
kobj = kobject_create();
kobject_add(kobj, parent, "%s", name);
return kobj;
}
struct kobject *kobject_create(void)
{
struct kobject *kobj;
kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
kobject_init(kobj, &dynamic_kobj_ktype);
return kobj;
}
/* 初始化kobject结构体 */
void kobject_init(struct kobject *kobj, struct kobj_type *ktype)
{
kobject_init_internal(kobj);
kobj->ktype = ktype;
}
int kobject_add(struct kobject *kobj, struct kobject *parent,
const char *fmt, ...)
{
va_list args;
va_start(args, fmt);
kobject_add_varg(kobj, parent, fmt, args);
va_end(args);
}
static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
const char *fmt, va_list vargs)
{
kobject_set_name_vargs(kobj, fmt, vargs);
kobj->parent = parent;
return kobject_add_internal(kobj);
}
/* 设置@kobj的name */
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
va_list vargs)
{
char *s;
kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
/* 名字中不能包含有'/'的字符，如果有，则直接截短 */
while ((s = strchr(kobj->name, '/')))
s[0] = '!';
}
dev_kobj = kobject_create_and_add("dev", NULL)创建的模型：
sysfs_dev_block_kobj = kobject_create_and_add("block", dev_kobj)与
sysfs_dev_char_kobj = kobject_create_and_add("char", dev_kobj)创建的模型
buses_init()
buses_init()创建sysfs模型如下：
/sys
├── bus
└── devices
└── system
```c
static struct kset *bus_kset;
static struct kset *system_kset; /* /sys/devices/system */
int __init buses_init(void)
{
bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL);
system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj);
}
bus_kset = kset_create_and_add("bus", &bus_uevent_ops, NULL)创建的模型：
system_kset = kset_create_and_add("system", NULL, &devices_kset->kobj)创建的模型：
platform_bus_init()
platform_bus_init()完成虚拟设备platform，及虚拟总线platform的创建。
/sys
└── devices
└── platform
└── uevent /* -rw-r--r-- */
```c
/* platform设备 */
struct device platform_bus = {
.init_name = "platform",
};
/* platform总线 */
struct bus_type platform_bus_type = {
.name = "platform",
.dev_groups = platform_dev_groups,
.match = platform_match,
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
int __init platform_bus_init(void)
{
early_platform_cleanup();
device_register(&platform_bus); /* 注册到devices目录中 */
bus_register(&platform_bus_type); /* 注册到bus目录中 */
of_platform_register_reconfig_notifier();
}
device_register()
/* 注册设备:初始化设备的数据结构，将其加入到数据结构的网络中。
完成设备注册后，可以在/sys/devices目录中看到 */
int device_register(struct device *dev)
{
device_initialize(dev); /* 初始化dev结构 */
device_add(dev); /* 添加dev至sysfs */
}
void device_initialize(struct device *dev)
{
/* 将设备kobject的kset集合指向devices_kset */
dev->kobj.kset = devices_kset;
kobject_init(&dev->kobj, &device_ktype);
}
#define DEVICE_ATTR_RW(_name) \
struct device_attribute dev_attr_##_name = __ATTR_RW(_name)
#define __ATTR_RW(_name) __ATTR(_name, (S_IWUSR | S_IRUGO), \
_name##_show, _name##_store)
#define __ATTR(_name, _mode, _show, _store) { \
.attr = {.name = __stringify(_name), \
.mode = VERIFY_OCTAL_PERMISSIONS(_mode) }, \
.show = _show, \
.store = _store, \
}
static DEVICE_ATTR_RW(uevent); /* 定义dev_attr_uevent，其展开宏如下：
struct device_attribute dev_attr_uevent {
.attr = {
.name = "uevent",
.mode = (S_IWUSR | S_IRUGO),
},
.show = uevent_show,
.store = uevent_store,
}; */
int device_add(struct device *dev)
{
struct device *parent = NULL;
struct kobject *kobj;
struct class_interface *class_intf;
/* 将设备的引用计数加1 */
dev = get_device(dev);
/* 创建私有数据结构体，并与主结构体进行关联 */
if (!dev->p) {
device_private_init(dev);
}
/* 使用dev.init_name设置dev.kobj.name，并置空dev.init_name */
if (dev->init_name) {
dev_set_name(dev, "%s", dev->init_name);
dev->init_name = NULL;
}
/* 如果kobject_add()的第二个参数parent为空，则以dev->kobj.kset.kobj作为父目录 */
kobject_add(&dev->kobj, dev->kobj.parent, NULL);
/* dev_attr_uevent由宏DEVICE_ATTR_RW()定义，在dev.kobj目录下创建以
dev_attr_uevent.attr.name命名，权限为dev_attr_uevent.attr.mode的文件 */
device_create_file(dev, &dev_attr_uevent);
/* 创建设备类型软链接 */
device_add_class_symlinks(dev);
bus_add_device(dev);
}
int bus_add_device(struct device *dev)
{
struct bus_type *bus = bus_get(dev->bus);
if (bus) {
device_add_attrs(bus, dev);
device_add_groups(dev, bus->dev_groups);
sysfs_create_link(&bus->p->devices_kset->kobj,
&dev->kobj, dev_name(dev));
sysfs_create_link(&dev->kobj,
&dev->bus->p->subsys.kobj, "subsystem");
klist_add_tail(&dev->p->knode_bus, &bus->p->klist_devices);
}
}
bus_register()
bus_register(&platform_bus_type)向系统添加一个新总线。
/sys
└── bus
└── platform
├── devices
├── drivers
├── drivers_autoprobe /* -rw-r--r-- /
├── drivers_probe / --w------- /
└── uevent / --w------- */
```c
struct bus_type {
const char * name; /* 总线的文本名称，用于在sysfs文件系统中标识总线 */
/* 试图查找与给定设备匹配的驱动程序 */
int (*match)(struct device * dev, struct device_driver * drv);
int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
/* 在有必要将驱动程序关联到设备时，会调用probe。该函数检测设备在系统中是否
真正存在 */
int (*probe)(struct device * dev);
/* 删除驱动程序和设备之间的关联。例如，在将可热挺拔的设备从系统中移除时，会
调用该函数 */
int (*remove)(struct device * dev);
struct subsys_private *p;
};
struct bus_type platform_bus_type = {
.name = "platform",
.dev_groups = platform_dev_groups,
.match = platform_match,
.uevent = platform_uevent,
.pm = &platform_dev_pm_ops,
};
static BUS_ATTR(uevent, S_IWUSR, NULL, bus_uevent_store); /* 定义bus_attr_uevent
，其展开宏如下：
struct bus_attribute bus_attr_uevent {
.attr = {
.name = "uevent",
.mode = S_IWUSR,
},
.show = NULL,
.store = bus_uevent_store,
}; */
/* 注册新的总线 */
int bus_register(struct bus_type *bus)
{
int retval;
struct subsys_private *priv;
struct lock_class_key *key = &bus->lock_key;
/* 框架设计机制：虽然可以直接用单个结构体来表示一种设备，但是更好的做法是把设备的私
有数据分离出来，每个设备用两个结构体表示，主结构体表示大家都存在的公共属性，并把
成员指针指向另一个表示私有属性的结构体。这样分离的另一个好处是，代码函数设计上更
加高内聚、低耦合。 */
priv = kzalloc(sizeof(struct subsys_private), GFP_KERNEL);
priv->bus = bus;
bus->p = priv;
/* */
kobject_set_name(&priv->subsys.kobj, "%s", bus->name);
priv->subsys.kobj.kset = bus_kset; /* 父目录指向bus_kset.kobj */
priv->subsys.kobj.ktype = &bus_ktype;
priv->drivers_autoprobe = 1;
/* 初始化&priv->subsys，并加入到sysfs */
kset_register(&priv->subsys);
/* bus_attr_uevent由宏BUS_ATTR()定义，在priv.subsys.kobj目录下创建以
bus_attr_uevent.attr.name命名，权限为bus_attr_uevent.attr.mode的文件 */
bus_create_file(bus, &bus_attr_uevent);
priv->devices_kset = kset_create_and_add("devices", NULL,
&priv->subsys.kobj);
priv->drivers_kset = kset_create_and_add("drivers", NULL,
&priv->subsys.kobj);
add_probe_files(bus); /* 创建drivers_probe与drivers_autoprobe文件 */
bus_add_groups(bus, bus->bus_groups);
}
内核设备模型框架
driver_init()最终形成的模型框架，如下所示：
/sys
├── bus
│ └── platform
│ ├── devices
│ ├── drivers
│ ├── drivers_autoprobe /* -rw-r--r-- */
│ ├── drivers_probe /* --w------- */
│ └── uevent /* --w------- */
├── dev
│ ├── block
│ └── char
└── devices
└── platform
└── uevent /* -rw-r--r-- */
