linux下bus、devices和platform的基础模型

﹏ヽ暗。殇╰゛Y 2022-03-26 17:41 152阅读 0赞

一、kobject的定义 :  
kobject是Linux2.6引入的设备管理机制,在内核中由struct kobject结构表示,这个结构使所有设备在底层都具有统一的接口.kobject提供了基本的对象管理能力,是构成Linux2.6设备模型的核心结构,它与sysfs文件系统紧密联系,每个在内核中注册kobject对象都对应与sysfs文件系统中的一个目录;kobject--->sysfs.dir;其结构定义为:  
struct kobject  
\{   
  const char\*        k\_name;              //指向设备名称的指针  
  char               name\[KOBJ\_NAME\_LEN\]; //设备名称  
  struct kref        kref;                //内核对象的引用计数  
  struct list\_head   entry;               //挂接到当前内核对象所在kset中的单元  
  struct kobject\*    parent;              //指向父对象的指针  
  struct kset\*       kset;                //内核对象所属kset的指针  
  struct kobj\_type\*  ktype;               //指向内核对象类型描述符的指针  
  struct dentry\*     dentry;              //sysfs文件系统中与该内核对象对应的文件节点路径的指针  
  wait\_queue\_head\_t  poll;                //IO等待队列;  
\};  
二、kobject相关函数 :  
1、void kobject\_init(struct kobject\* kobj);  
   该函数用于初始化kobject对象,它设置kobject对象的引用计数为1,entry字段指向自身,其所属kset对象的引用计数加1;  
2、void kobject\_cleanup(struct kobject\* kobj);  
   void kobject\_release(struct kref\* ref);  
   这两个函数用于清除kobject对象,当其引用计数为0时,释放对象所占用的资源;  
3、int kobject\_set\_name(struct kobject\* kobj, const char\* format, ...);  
   该函数用于设置指定kobject对象的名称;  
4、const char\* kobject\_name(const struct kobject\* kobj);  
   该函数用于返回指定kobject的名称;  
5、int kobject\_rename(struct kobject\* kobj, const char\* new\_name);  
   该函数用于为指定kobject对象重命名;  
6、struct kobject\* kobject\_get(struct kobject\* kobj);  
   该函数用于将kobject对象的引用计数加1,相当于申请了一个kobject对象资源,同时返回该kobject对象的指针;  
7、void kobject\_put(struct kobject\* kobj);  
   该函数用于将kobject对象的引用计数减1,相当于释放了一个kobject对象资源;当引用计数为0时,则调用kobject\_release()释放该kobject对象的资源;  
8、int kobject\_add(struct kobject\* kobj);  
   该函数用于注册kobject对象,即:加入到Linux的设备层次中,它会挂接该kobject对象到kset的list链中,增加父目录各级kobject对象的引用计数,在其parent字段指向的目录下创建对应的文件节点,并启动该类型kobject对象的hotplug()函数;  
9、void kobject\_del(struct kobject\* kobj);  
   该函数与kobject\_add()相反,用于注销kobject对象,即:中止该kobject对象的hotplug()函数,从Linux的设备层次中删除该kobject对象,删除该kobject对象在sysfs文件系统中对应的文件节点;  
10、int kobject\_register(struct kobject\* obj);  
    该函数用于注册kobject对象,它首先会调用kobject\_init()初始化kobj,然后再调用kobject\_add()完成该内核对象的添加;  
11、void kobject\_unregister(struct kobject\* kobj);  
    该函数与kobject\_register()相反,用于注销kobject对象,它首先调用kobject\_del()从Linux的设备层次中删除kobject对象,再调用kobject\_put()减少该kobject对象的引用计数,当引用计数为0时,则释放该kobject对象的资源;  
12、struct kobject\* kobject\_add\_dir(struct kobject\*, const char\* path);  
    该函数用于在sysfs文件系统中为该kobject对象创建对应的目录;  
13、char\* kobject\_get\_path(struct kobject\* kobj);  
    该函数用于返回该kobject对象在sysfs文件系统中的对应目录路径;  
三、kobject的行为 :  
typedef int \_\_bitwise kobject\_action\_t;  
enum kobject\_action  
\{   
  KOBJ\_ADD     = (\_\_force kobject\_action\_t) 0x01, //exclusive to core  
  KOBJ\_REMOVE  = (\_\_force kobject\_action\_t) 0x02, //exclusive to core  
  KOBJ\_CHANGE  = (\_\_force kobject\_action\_t) 0x03, //device state change  
  KOBJ\_MOUNT   = (\_\_force kobject\_action\_t) 0x04, //mount event for block devices (broken)  
  KOBJ\_UMOUNT  = (\_\_force kobject\_action\_t) 0x05, //umount event for block devices (broken)  
  KOBJ\_OFFLINE = (\_\_force kobject\_action\_t) 0x06, //device offline  
  KOBJ\_ONLINE  = (\_\_force kobject\_action\_t) 0x07, //device online  
\};  
该枚举类型用于定义kobject对象的状态更新消息码,也就是热插拔事件码;  
备注 :struct kobject结构定义于文件include/linux/kobject.h  
  
下面转自： [http://blog.chinaunix.net/u1/57901/showart\_1803248.html][http_blog.chinaunix.net_u1_57901_showart_1803248.html]

在LINUX中最让人不解的大概就是/sys下面的内容了

下面首先让我们来创建一个简单的platform设备,并从这个设备的视角进行深入,在此篇文章的深入过程中,我们只看kobeject的模型我所使用的内核版本号为2.6.26,操作系统的内核版本号为2.6.27-7,暂未发现2.6.27-7与2.6.26的重大不同

首先写一个简单的模块

\#include <linux/platform\_device.h>

\#include <linux/init.h>

\#include <linux/module.h>

static int \_\_init test\_probe(struct platform\_device \*pdev)

int err = 0;

return err;

static int test\_remove(struct platform\_device \*pdev)

return 0;

static struct platform\_device test\_device = \{

.name = "test\_ts",

.id = -1,

\};

static struct platform\_driver test\_driver = \{

.probe                = test\_probe,

.remove                = test\_remove,

.driver                = \{

.name        = "test\_ts",

.owner        = THIS\_MODULE,

\},

\};

static int \_\_devinit test\_init(void)

platform\_device\_register(&test\_device);

return platform\_driver\_register(&test\_driver);

static void \_\_exit test\_exit(void)

platform\_device\_unregister(&test\_device);

platform\_driver\_unregister(&test\_driver);

module\_init(test\_init);

module\_exit(test\_exit);

MODULE\_AUTHOR("zwolf");

MODULE\_DESCRIPTION("Module test");

MODULE\_LICENSE("GPL");

MODULE\_ALIAS("test");

接下来是makefile

\#Makefile

obj-m:=test.o

KDIR:=/lib/modules/2.6.27-7-generic/build

PWD:=$(shell pwd)

default:

$(MAKE) -C $(KDIR) M=$(PWD) modules

KDIR中的目录请改为各位实际运行中的内核目录make之后进行模块的加载 sudo insmod ./test.ko

现在到sys目录中查看我们的设备是否已经加载上了

首先是/sys/bus/platform/devices/在devices下,每一个连接文件都代表了一个设备ls可看见test\_ts,进入test\_ts,ls可发现driver这个链接文件,ls-l查看,发现这个文件是连到/sys/bus/platform/drivers/test\_ts的

这里需要说明的是连接的含义,并不是driver驱动存在于test\_ts这个设备中,而是test\_ts使用的驱动为/sys/bus/platform/drivers/test\_ts

现在换到/sys/bus/platform/drivers这个目录下

ls查看会发现这里的文件都为目录,而非连接文件,说明这是驱动真正放置的位置

现在进入test\_ts目录,然后ls,发现有一个test\_ts的连接文件,ls –l查看可发现该文件连接到/sys/devices/platform/test\_ts下

回到/sys/bus/platform/devices/下ls –l也会发现test\_ts连接到/sys/devices/platform/test\_ts

为什么test\_ts这个设备放置于/sys/devices/platform下,而不是/sys/bus/platform/devices下呢

我认为和直观性有关,在sys下有这么几个目录block  bus  class  dev  devices  firmware  kernel  module  fs power

devices很直观的说明了设备在这个目录下  
再来看组成这个目录图的核心,kobject图,我也叫他层次图  
![Image 1][]

不看大号绿色箭头右边的内容的话是不是发现两个架构相同?

对的,kobject的层次决定了目录的结构

kobeject图很大,但也不要担心,里面的内容其实不多,基础框架涉及3个主要结构kset kobject和ktype

在说明test\_ts的注册之前,先让我们看一下sys下的两个基础目录bus,devices

首先是bus

bus的注册在/drivers/base/bus.c里

int \_\_init buses\_ini

t(void)

bus\_kset = kset\_create\_and\_add("bus", &bus\_uevent\_ops, NULL);

if (!bus\_kset)

return -ENOMEM;

return 0;

先看bus\_uevent\_ops,这是一个uevent的操作集(我也还没清楚uevent的用途,所以uevent的内容先放着)

然后到kset\_create\_and\_add

struct kset \*kset\_create\_and\_add(const char \*name,

struct kset\_uevent\_ops \*uevent\_ops,

struct kobject \*parent\_kobj)

//传递进来的参数为("bus", &bus\_uevent\_ops, NULL)

struct kset \*kset;

int error;

//创建一个kset容器

kset = kset\_create(name, uevent\_ops, parent\_kobj);

if (!kset)

return NULL;

//注册创建的kset容器

error = kset\_register(kset);

if (error) \{

kfree(kset);

return NULL;

return kset;

首先需要创建一个kset容器

static struct kset \*kset\_create(const char \*name,

struct kset\_uevent\_ops \*uevent\_ops,

struct kobject \*parent\_kobj)

//传递进来的参数为("bus", &bus\_uevent\_ops, NULL)

struct kset \*kset;

//为kset分配内存

kset = kzalloc(sizeof(\*kset), GFP\_KERNEL);

if (!kset)

return NULL;

//设置kset中kobject的名字,这里为bus

kobject\_set\_name(&kset->kobj, name);

//设置uevent操作集,这里为bus\_uevent\_ops

kset->uevent\_ops = uevent\_ops;

//设置父对象,这里为NULL

kset->kobj.parent = parent\_kobj;

//设置容器操作集

kset->kobj.ktype = &kset\_ktype;

//设置父容器

kset->kobj.kset = NULL;

return kset;

这里的ktype,也就是kset\_ktype是一个操作集,用于为sys下文件的实时反馈做服务,例如我们cat name的时候就要通过ktype提供的show函数,具体什么怎么运用,将在后面讲解

现在回到kset\_create\_and\_add中的kset\_register,将建立好的kset添加进sys里

int kset\_register(struct kset \*k)

int err;

if (!k)

return -EINVAL;

//初始化

kset\_init(k);

//添加该容器

err = kobject\_add\_internal(&k->kobj);

if (err)

return err;

kobject\_uevent(&k->kobj, KOBJ\_ADD);

return 0;

kset\_init进行一些固定的初始化操作,里面没有我们需要关心的内容

kobject\_add\_internal为重要的一个函数,他对kset里kobj的从属关系进行解析,搭建正确的架构

static int kobject\_add\_internal(struct kobject \*kobj)

int error = 0;

struct kobject \*parent;

//检测kobj是否为空

if (!kobj)

return -ENOENT;

//检测kobj名字是否为空

if (!kobj->name || !kobj->name\[0\]) \{

pr\_debug("kobject: (%p): attempted to be registered with empty "

"name!\\n", kobj);

WARN\_ON(1);

return -EINVAL;

//提取父对象

parent = kobject\_get(kobj->parent);

/\* join kset if set, use it as parent if we do not already have one \*/

//父容器存在则设置父对象

if (kobj->kset) \{//在bus的kset中为空,所以不会进入到下面的代码

//检测是否已经设置父对象

if (!parent)

//无则使用父容器为父对象

parent = kobject\_get(&kobj->kset->kobj);

//添加该kobj到父容器的链表中

kobj\_kset\_join(kobj);

//设置父对象

kobj->parent = parent;

pr\_debug("kobject: '%s' (%p): %s: parent: '%s', set: '%s'\\n",

kobject\_name(kobj), kobj, \_\_func\_\_,

parent ? kobject\_name(parent) : "<NULL>",

kobj->kset ? kobject\_name(&kobj->kset->kobj) : "<NULL>");

//建立相应的目录

error = create\_dir(kobj);

if (error) \{

kobj\_kset\_leave(kobj);

kobject\_put(parent);

kobj->parent = NULL;

if (error == -EEXIST)

printk(KERN\_ERR "%s failed for %s with "

"-EEXIST, don't try to register things with "

"the same name in the same directory.\\n",

\_\_func\_\_, kobject\_name(kobj));

else

printk(KERN\_ERR "%s failed for %s (%d)\\n",

\_\_func\_\_, kobject\_name(kobj), error);

dump\_stack();

\} else

kobj->state\_in\_sysfs = 1;

return error;

至此bus的目录就建立起来了

模型如下  
![Image 1][]

接下来是devices,在/drivers/base/core.c里

int \_\_init devices\_init(void)

devices\_kset = kset\_create\_and\_add("devices", &device\_uevent\_ops, NULL);

if (!devices\_kset)

return -ENOMEM;

return 0;

过程和bus的注册一致,我就不复述了~

模型如下  
![Image 1][]

然后是platform的注册

在platform的注册中,分为两个部分,一部分是注册到devices中,另一部分是注册到bus中,代码在/drivers/base/platform.c中

int \_\_init platform\_bus\_init(void)

int error;

//注册到devices目录中

error = device\_register(&platform\_bus);

if (error)

return error;

//注册到bus目录中

error =  bus\_register(&platform\_bus\_type);

if (error)

device\_unregister(&platform\_bus);

return error;

首先是device\_register,注册的参数为platform\_bus,如下所示

struct device platform\_bus = \{

.bus\_id                = "platform",

\};

很简单,只有一个参数,表明了目录名

int device\_register(struct device \*dev)

//初始化dev结构

device\_initialize(dev);

//添加dev至目录

return device\_add(dev);

void device\_initialize(struct device \*dev)

//重要的一步,指明了父容器为devices\_kset,而devices\_kset的注册在前面已经介绍过了

dev->kobj.kset = devices\_kset;

//初始化kobj的ktype为device\_ktype

kobject\_init(&dev->kobj, &device\_ktype);

klist\_init(&dev->klist\_children, klist\_children\_get,

klist\_children\_put);

INIT\_LIST\_HEAD(&dev->dma\_pools);

INIT\_LIST\_HEAD(&dev->node);

init\_MUTEX(&dev->sem);

spin\_lock\_init(&dev->devres\_lock);

INIT\_LIST\_HEAD(&dev->devres\_head);

device\_init\_wakeup(dev, 0);

set\_dev\_node(dev, -1);

int device\_add(struct device \*dev)

struct device \*parent = NULL;

struct class\_interface \*class\_intf;

int error;

dev = get\_device(dev);

if (!dev || !strlen(dev->bus\_id)) \{

error = -EINVAL;

goto Done;

pr\_debug("device: '%s': %s\\n", dev->bus\_id, \_\_func\_\_);

parent = get\_device(dev->parent);

setup\_parent(dev, parent);

if (parent)

set\_dev\_node(dev, dev\_to\_node(parent));

//设置dev->kobj的名字和父对象,并建立相应的目录

error = kobject\_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus\_id);

if (error)

goto Error;

if (platform\_notify)

platform\_notify(dev);

if (dev->bus)

blocking\_notifier\_call\_chain(&dev->bus->p->bus\_notifier,

BUS\_NOTIFY\_ADD\_DEVICE, dev);

//建立uevent文件

error = device\_create\_file(dev, &uevent\_attr);

if (error)

goto attrError;

if (MAJOR(dev->devt)) \{

error = device\_create\_file(dev, &devt\_attr);

if (error)

goto ueventattrError;

//建立subsystem连接文件连接到所属class,这里没有设置class对象所以不会建立

error = device\_add\_class\_symlinks(dev);

if (error)

goto SymlinkError;

//建立dev的描述文件,这里没有设置描述文件所以不会建立

error = device\_add\_attrs(dev);

if (error)

goto AttrsError;

//建立链接文件至所属bus,这里没有设置所属bus所以不会建立

error = bus\_add\_device(dev);

if (error)

goto BusError;

//添加power文件,因为platform不属于设备,所以不会建立power文件

error = device\_pm\_add(dev);

if (error)

goto PMError;

kobject\_uevent(&dev->kobj, KOBJ\_ADD);

//检测驱动中有无适合的设备进行匹配,但没有设置bus,所以不会进行匹配

bus\_attach\_device(dev);

if (parent)

klist\_add\_tail(&dev->knode\_parent, &parent->klist\_children);

if (dev->class) \{

down(&dev->class->sem);

list\_add\_tail(&dev->node, &dev->class->devices);

list\_for\_each\_entry(class\_intf, &dev->class->interfaces, node)

if (class\_intf->add\_dev)

class\_intf->add\_dev(dev, class\_intf);

up(&dev->class->sem);

Done:

put\_device(dev);

return error;

PMError:

bus\_remove\_device(dev);

BusError:

if (dev->bus)

blocking\_notifier\_call\_chain(&dev->bus->p->bus\_notifier,

BUS\_NOTIFY\_DEL\_DEVICE, dev);

device\_remove\_attrs(dev);

AttrsError:

device\_remove\_class\_symlinks(dev);

SymlinkError:

if (MAJOR(dev->devt))

device\_remove\_file(dev, &devt\_attr);

ueventattrError:

device\_remove\_file(dev, &uevent\_attr);

attrError:

kobject\_uevent(&dev->kobj, KOBJ\_REMOVE);

kobject\_del(&dev->kobj);

Error:

cleanup\_device\_parent(dev);

if (parent)

put\_device(parent);

goto Done;

在kobject\_add-> kobject\_add\_varg-> kobject\_add\_internal中

//提取父对象,因为没有设置,所以为空

parent = kobject\_get(kobj->parent);

//父容器存在则设置父对象,在前面的dev->kobj.kset = devices\_kset中设为了devices\_kset

if (kobj->kset) \{

//检测是否已经设置父对象

if (!parent)

//无则使用父容器为父对象

parent = kobject\_get(&kobj->kset->kobj);

//添加该kobj到父容器的链表中

kobj\_kset\_join(kobj);

//设置父对象

kobj->parent = parent;

现在devices下的platform目录建立好了,模型如下,其中红线描绘了目录关系  
![Image 1][]

现在到bus\_register了

注册的参数platform\_bus\_type如下所示

struct bus\_type platform\_bus\_type = \{

.name                = "platform",

.dev\_attrs        = platform\_dev\_attrs,

.match                = platform\_match,

.uevent                = platform\_uevent,

.suspend                = platform\_suspend,

.suspend\_late        = platform\_suspend\_late,

.resume\_early        = platform\_resume\_early,

.resume                = platform\_resume,

\};

int bus\_register(struct bus\_type \*bus)

int retval;

//声明一个总线私有数据并分配空间

struct bus\_type\_private \*priv;

priv = kzalloc(sizeof(struct bus\_type\_private), GFP\_KERNEL);

if (!priv)

return -ENOMEM;

//互相关联

priv->bus = bus;

bus->p = priv;

BLOCKING\_INIT\_NOTIFIER\_HEAD(&priv->bus\_notifier);

//设置私有数据中kobj对象的名字

retval = kobject\_set\_name(&priv->subsys.kobj, "%s", bus->name);

if (retval)

goto out;

//设置父容器为bus\_kset,操作集为bus\_ktype

priv->subsys.kobj.kset = bus\_kset;

priv->subsys.kobj.ktype = &bus\_ktype;

priv->drivers\_autoprobe = 1;

//注册bus容器

retval = kset\_register(&priv->subsys);

if (retval)

goto out;

//建立uevent属性文件

retval = bus\_create\_file(bus, &bus\_attr\_uevent);

if (retval)

goto bus\_uevent\_fail;

//建立devices目录

priv->devices\_kset = kset\_create\_and\_add("devices", NULL,

&priv->subsys.kobj);

if (!priv->devices\_kset) \{

retval = -ENOMEM;

goto bus\_devices\_fail;

//建立drivers目录

priv->drivers\_kset = kset\_create\_and\_add("drivers", NULL,

&priv->subsys.kobj);

if (!priv->drivers\_kset) \{

retval = -ENOMEM;

goto bus\_drivers\_fail;

//初始化klist\_devices和klist\_drivers链表

klist\_init(&priv->klist\_devices, klist\_devices\_get, klist\_devices\_put);

klist\_init(&priv->klist\_drivers, NULL, NULL);

//增加probe属性文件

retval = add\_probe\_files(bus);

if (retval)

goto bus\_probe\_files\_fail;

//增加总线的属性文件

retval = bus\_add\_attrs(bus);

if (retval)

goto bus\_attrs\_fail;

pr\_debug("bus: '%s': registered\\n", bus->name);

return 0;

bus\_attrs\_fail:

remove\_probe\_files(bus);

bus\_probe\_files\_fail:

kset\_unregister(bus->p->drivers\_kset);

bus\_drivers\_fail:

kset\_unregister(bus->p->devices\_kset);

bus\_devices\_fail:

bus\_remove\_file(bus, &bus\_attr\_uevent);

bus\_uevent\_fail:

kset\_unregister(&bus->p->subsys);

kfree(bus->p);

out:

return retval;

在kset\_register-> kobject\_add\_internal中

//提取父对象,因为没有设置父对象,所以为空

parent = kobject\_get(kobj->parent);

//父容器存在则设置父对象,在上文中设置了父容器priv->subsys.kobj.kset = bus\_kset

if (kobj->kset) \{

//检测是否已经设置父对象

if (!parent)

//无则使用父容器为父对象

parent = kobject\_get(&kobj->kset->kobj);

//添加该kobj到父容器的链表中

kobj\_kset\_join(kobj);

//设置父对象

kobj->parent = parent;

在retval = kset\_register(&priv->subsys)完成之后platform在bus下的模型如下图

![Image 1][]

有印象的话大家还记得在platform下面有两个目录devices和drivers吧~

现在就到这两个目录的注册了

priv->devices\_kset = kset\_create\_and\_add("devices", NULL,&priv->subsys.kobj);

priv->drivers\_kset = kset\_create\_and\_add("drivers", NULL, &priv->subsys.kobj);

注意这两条语句的头部

priv->devices\_kset = kset\_create\_and\_add

priv->drivers\_kset = kset\_create\_and\_add

可以清楚的看到bus\_type\_private下的devices\_kset, drivers\_kset分别连接到了devices,drivers的kset上

现在来看kset\_create\_and\_add("devices", NULL,&priv->subsys.kobj);

struct kset \*kset\_create\_and\_add(const char \*name,

struct kset\_uevent\_ops \*uevent\_ops,

struct kobject \*parent\_kobj)

//参数为"devices", NULL,&priv->subsys.kobj

struct kset \*kset;

int error;

//创建一个kset容器

kset = kset\_create(name, uevent\_ops, parent\_kobj);

if (!kset)

return NULL;

//注册创建的kset容器

error = kset\_register(kset);

if (error) \{

kfree(kset);

return NULL;

return kset;

在kset\_create 中比较重要的操作为

kset->kobj.ktype = &kset\_ktype //设置了ktype,为kset\_ktype

kset->kobj.parent = parent\_kobj; //设置了父对象,为priv->subsys.kobj,也就是platform\_bus\_type->p->subsys.kobj

kset->kobj.kset = NULL;    //设置父容器为空

在kset\_register中

//提取父对象

parent = kobject\_get(kobj->parent); //在之前设置为了

//父容器存在则设置父对象,由于父容器为空,不执行以下代码

if (kobj->kset) \{

//检测是否已经设置父对象

if (!parent)

//无则使用父容器为父对象

parent = kobject\_get(&kobj->kset->kobj);

//添加该kobj到父容器的链表中

kobj\_kset\_join(kobj);

//设置父对象

kobj->parent = parent;

至此, devices的模型就建立好了,drivers模型的建立和devices是一致的,只是名字不同而已,我就不复述了,建立好的模型如下

![Image 1][]

好了~  到了这里,bus,devices和platform的基础模型就就建立好了,就等设备来注册了

在platform模型设备的建立中,需要2个部分的注册,驱动的注册和设备的注册

platform\_device\_register(&test\_device);

platform\_driver\_register(&test\_driver);

首先看platform\_device\_register

注册参数为test\_device,结构如下

static struct platform\_device test\_device = \{

.name = "test\_ts",

.id = -1,

//. resource

//.dev

\};

这个结构主要描述了设备的名字,ID和资源和私有数据,其中资源和私有数据我们在这里不使用,将在别的文章中进行讲解

int platform\_device\_register(struct platform\_device \*pdev)

//设备属性的初始化

device\_initialize(&pdev->dev);

//将设备添加进platform里

return platform\_device\_add(pdev);

void device\_initialize(struct device \*dev)

dev->kobj.kset = devices\_kset;                   //设置kset为devices\_kset,则将设备挂接上了devices目录

kobject\_init(&dev->kobj, &device\_ktype);                    //初始化kobeject,置ktype为device\_ktype

klist\_init(&dev->klist\_children, klist\_children\_get,

klist\_children\_put);

INIT\_LIST\_HEAD(&dev->dma\_pools);

INIT\_LIST\_HEAD(&dev->node);

init\_MUTEX(&dev->sem);

spin\_lock\_init(&dev->devres\_lock);

INIT\_LIST\_HEAD(&dev->devres\_head);

device\_init\_wakeup(dev, 0);

set\_dev\_node(dev, -1);

int platform\_device\_add(struct platform\_device \*pdev)

int i, ret = 0;

if (!pdev)

return -EINVAL;

//检测是否设置了dev中的parent,无则赋为platform\_bus

if (!pdev->dev.parent)

pdev->dev.parent = &platform\_bus;

//设置dev中的bus为platform\_bus\_type

pdev->dev.bus = &platform\_bus\_type;

//检测id,id为-1表明该设备只有一个,用设备名为bus\_id

//不为1则表明该设备有数个,需要用序号标明bus\_id

if (pdev->id != -1)

snprintf(pdev->dev.bus\_id, BUS\_ID\_SIZE, "%s.%d", pdev->name,

pdev->id);

else

strlcpy(pdev->dev.bus\_id, pdev->name, BUS\_ID\_SIZE);

//增加资源到资源树中

for (i = 0; i < pdev->num\_resources; i++) \{

struct resource \*p, \*r = &pdev->resource;

if (r->name == NULL)

r->name = pdev->dev.bus\_id;

p = r->parent;

if (!p) \{

if (r->flags & IORESOURCE\_MEM)

p = &iomem\_resource;

else if (r->flags & IORESOURCE\_IO)

p = &ioport\_resource;

if (p && insert\_resource(p, r)) \{

printk(KERN\_ERR "%s: failed to claim resource %d\\n",pdev->dev.bus\_id, i);

ret = -EBUSY;

goto failed;

pr\_debug("Registering platform device '%s'. Parent at %s\\n",pdev->dev.bus\_id, pdev->dev.parent->bus\_id);

//添加设备到设备层次中

ret = device\_add(&pdev->dev);

if (ret == 0)

return ret;

failed:

while (--i >= 0)

if (pdev->resource.flags & (IORESOURCE\_MEM|IORESOURCE\_IO))

release\_resource(&pdev->resource);

return ret;

int device\_add(struct device \*dev)

struct device \*parent = NULL;

struct class\_interface \*class\_intf;

int error;

dev = get\_device(dev);

if (!dev || !strlen(dev->bus\_id)) \{

error = -EINVAL;

goto Done;

pr\_debug("device: '%s': %s\\n", dev->bus\_id, \_\_func\_\_);

//取得上层device,而dev->parent的赋值是在platform\_device\_add中的pdev->dev.parent = &platform\_bus完成的

parent = get\_device(dev->parent);

//以上层devices为准重设dev->kobj.parent

setup\_parent(dev, parent);

if (parent)

set\_dev\_node(dev, dev\_to\_node(parent));

//设置dev->kobj的名字和父对象,并建立相应目录

error = kobject\_add(&dev->kobj, dev->kobj.parent, "%s", dev->bus\_id);

if (error)

goto Error;

if (platform\_notify)

platform\_notify(dev);

//一种新型的通知机制,但是platform中没有设置相应的结构,所以在这里跳过

/\* notify clients of device entry (new way) \*/

if (dev->bus)

blocking\_notifier\_call\_chain(&dev->bus->p->bus\_notifier,BUS\_NOTIFY\_ADD\_DEVICE, dev);

//建立uevent文件

error = device\_create\_file(dev, &uevent\_attr);

if (error)

goto attrError;

//设备有设备号则建立dev文件

if (MAJOR(dev->devt)) \{

error = device\_create\_file(dev, &devt\_attr);

if (error)

goto ueventattrError;

//建立subsystem连接文件连接到所属class

error = device\_add\_class\_symlinks(dev);

if (error)

goto SymlinkError;

//添加dev的描述文件

error = device\_add\_attrs(dev);

if (error)

goto AttrsError;

//添加链接文件至所属bus

error = bus\_add\_device(dev);

if (error)

goto BusError;

//添加power文件

error = device\_pm\_add(dev);

if (error)

goto PMError;

kobject\_uevent(&dev->kobj, KOBJ\_ADD);

//检测驱动中有无适合的设备进行匹配,现在只添加了设备,还没有加载驱动,所以不会进行匹配

bus\_attach\_device(dev);

if (parent)

klist\_add\_tail(&dev->knode\_parent, &parent->klist\_children);

if (dev->class) \{

down(&dev->class->sem);

list\_add\_tail(&dev->node, &dev->class->devices);

list\_for\_each\_entry(class\_intf, &dev->class->interfaces, node)

if (class\_intf->add\_dev)

class\_intf->add\_dev(dev, class\_intf);

up(&dev->class->sem);

Done:

put\_device(dev);

return error;

PMError:

bus\_remove\_device(dev);

BusError:

if (dev->bus)

blocking\_notifier\_call\_chain(&dev->bus->p->bus\_notifier,BUS\_NOTIFY\_DEL\_DEVICE, dev);

device\_remove\_attrs(dev);

AttrsError:

device\_remove\_class\_symlinks(dev);

SymlinkError:

if (MAJOR(dev->devt))

device\_remove\_file(dev, &devt\_attr);

ueventattrError:

device\_remove\_file(dev, &uevent\_attr);

attrError:

kobject\_uevent(&dev->kobj, KOBJ\_REMOVE);

kobject\_del(&dev->kobj);

Error:

cleanup\_device\_parent(dev);

if (parent)

put\_device(parent);

goto Done;

static void setup\_parent(struct device \*dev, struct device \*parent)

struct kobject \*kobj;

//取得上层device的kobj

kobj = get\_device\_parent(dev, parent);

//kobj不为空则重设dev->kobj.parent

if (kobj)

dev->kobj.parent = kobj;

static struct kobject \*get\_device\_parent(struct device \*dev,

struct device \*parent)

int retval;

//因为dev->class为空,所以跳过这段代码

if (dev->class) \{

struct kobject \*kobj = NULL;

struct kobject \*parent\_kobj;

struct kobject \*k;

if (parent == NULL)

parent\_kobj = virtual\_device\_parent(dev);

else if (parent->class)

return &parent->kobj;

else

parent\_kobj = &parent->kobj;

spin\_lock(&dev->class->class\_dirs.list\_lock);

list\_for\_each\_entry(k, &dev->class->class\_dirs.list, entry)

if (k->parent == parent\_kobj) \{

kobj = kobject\_get(k);

break;

spin\_unlock(&dev->class->class\_dirs.list\_lock);

if (kobj)

return kobj;

k = kobject\_create();

if (!k)

return NULL;

k->kset = &dev->class->class\_dirs;

retval = kobject\_add(k, parent\_kobj, "%s", dev->class->name);

if (retval < 0) \{

kobject\_put(k);

return NULL;

return k;

if (parent)

//返回上层device的kobj

return &parent->kobj;

return NULL;

在bus\_attach\_device中虽然没有成功进行匹配,但是有很重要的一步为之后正确的匹配打下基础

void bus\_attach\_device(struct device \*dev)

struct bus\_type \*bus = dev->bus;

int ret = 0;

if (bus) \{

if (bus->p->drivers\_autoprobe)

ret = device\_attach(dev);

WARN\_ON(ret < 0);

if (ret >= 0)

klist\_add\_tail(&dev->knode\_bus, &bus->p->klist\_devices);

klist\_add\_tail(&dev->knode\_bus, &bus->p->klist\_devices)就是这一行

在这一行代码中将设备挂载到了bus下的devices链表下,这样,当驱动请求匹配的时候,platform总线就会历遍devices链表为驱动寻找合适的设备

现在来看一下test\_device的模型  
![Image 1][]

然后platform\_driver\_unregister,他的参数 test\_driver的结构如下

static struct platform\_driver test\_driver = \{

.probe                = test\_probe,

.remove                = test\_remove,

.driver                = \{

.name        = "test\_ts",

.owner        = THIS\_MODULE,

\},

\};

int platform\_driver\_register(struct platform\_driver \*drv)

drv->driver.bus = &platform\_bus\_type;

if (drv->probe)

drv->driver.probe = platform\_drv\_probe;

if (drv->remove)

drv->driver.remove = platform\_drv\_remove;

if (drv->shutdown)

drv->driver.shutdown = platform\_drv\_shutdown;

if (drv->suspend)

drv->driver.suspend = platform\_drv\_suspend;

if (drv->resume)

drv->driver.resume = platform\_drv\_resume;

return driver\_register(&drv->driver);

从上面代码可以看出,在platform\_driver中设置了probe, remove, shutdown, suspend或resume函数的话

则drv->driver也会设置成platform对应的函数

int driver\_register(struct device\_driver \*drv)

int ret;

struct device\_driver \*other;

//检测总线的操作函数和驱动的操作函数是否同时存在,同时存在则提示使用总线提供的操作函数

if ((drv->bus->probe && drv->probe) ||

(drv->bus->remove && drv->remove) ||

(drv->bus->shutdown && drv->shutdown))

printk(KERN\_WARNING "Driver '%s' needs updating - please use ""bus\_type methods\\n", drv->name);

//检测是否已经注册过

other = driver\_find(drv->name, drv->bus);

if (other) \{

put\_driver(other);

printk(KERN\_ERR "Error: Driver '%s' is already registered, “"aborting...\\n", drv->name);

return -EEXIST;

//添加驱动到总线上

ret = bus\_add\_driver(drv);

if (ret)

return ret;

ret = driver\_add\_groups(drv, drv->groups);

if (ret)

bus\_remove\_driver(drv);

return ret;

int bus\_add\_driver(struct device\_driver \*drv)

struct bus\_type \*bus;

struct driver\_private \*priv;

int error = 0;

//取bus结构

bus = bus\_get(drv->bus);

if (!bus)

return -EINVAL;

pr\_debug("bus: '%s': add driver %s\\n", bus->name, drv->name);

//分配驱动私有数据

priv = kzalloc(sizeof(\*priv), GFP\_KERNEL);

if (!priv) \{

error = -ENOMEM;

goto out\_put\_bus;

//初始化klist\_devices链表

klist\_init(&priv->klist\_devices, NULL, NULL);

//互相关联

priv->driver = drv;

drv->p = priv;

//设置私有数据的父容器,在这一步中,设置了kset为platform下的drivers\_kset结构,也就是drivers呢个目录

priv->kobj.kset = bus->p->drivers\_kset;

//初始化kobj对象,设置容器操作集并建立相应的目录,这里由于没有提供parent,所以会使用父容器中的kobj为父对象

error = kobject\_init\_and\_add(&priv->kobj, &driver\_ktype, NULL,

"%s", drv->name);

if (error)

goto out\_unregister;

//检测所属总线的drivers\_autoprobe属性是否为真

//为真则进行与设备的匹配,到这里,就会与我们之前注册的test\_device连接上了,至于如何连接,进行了什么操作,将在别的文章中详细描述

if (drv->bus->p->drivers\_autoprobe) \{

error = driver\_attach(drv);

if (error)

goto out\_unregister;

//挂载到所属总线驱动链表上

klist\_add\_tail(&priv->knode\_bus, &bus->p->klist\_drivers);

module\_add\_driver(drv->owner, drv);

//建立uevent属性文件

error = driver\_create\_file(drv, &driver\_attr\_uevent);

if (error) \{

printk(KERN\_ERR "%s: uevent attr (%s) failed\\n",

\_\_func\_\_, drv->name);

//建立设备属性文件

error = driver\_add\_attrs(bus, drv);

if (error) \{

printk(KERN\_ERR "%s: driver\_add\_attrs(%s) failed\\n",\_\_func\_\_, drv->name);

error = add\_bind\_files(drv);

if (error) \{

printk(KERN\_ERR "%s: add\_bind\_files(%s) failed\\n",\_\_func\_\_, drv->name);

kobject\_uevent(&priv->kobj, KOBJ\_ADD);

return error;

out\_unregister:

kobject\_put(&priv->kobj);

out\_put\_bus:

bus\_put(bus);

return error;

到这里test\_driver的模型就建立好了,图就是最上面的层次图,我就不再贴了

到这里一个基本的框架就建立起来了~

下面,我开始对kobject kset和ktype做分析

先说说关系,ktype与kobject和kset这两者之前的关系较少,让我画一个图,是这样的  
![Image 1][]

ktype依赖于kobject,kset也依赖于kobject,而kobject有时需要kset(所以用了一个白箭头),不一定需要ktype(真可怜,连白箭头都没有)

首先先说一下这个可有可无的ktype

到/sys/bus/platform下面可以看见一个drivers\_autoprobe的文件

cat drivers\_autoprobe可以查看这个文件的值

echo 0 > drivers\_autoprobe则可以改变这个文件的值

drivers\_autoprobe这个文件表示的是是否自动进行初始化

在

void bus\_attach\_device(struct device \*dev)

struct bus\_type \*bus = dev->bus;

int ret = 0;

if (bus) \{

if (bus->p->drivers\_autoprobe)

ret = device\_attach(dev);

WARN\_ON(ret < 0);

if (ret >= 0)

klist\_add\_tail(&dev->knode\_bus, &bus->p->klist\_devices);

中可以看见这么一段代码

if (bus->p->drivers\_autoprobe)

ret = device\_attach(dev);

bus->p->drivers\_autoprobe的值为真则进行匹配

而drivers\_autoprobe这个文件则可以动态的修改这个值选择是否进行匹配

使用外部文件修改内核参数,ktype就是提供了这么一种方法

现在让我们看看ktype是怎么通过kobject进行运作的

首先是ktype及通过ktype进行运作的drivers\_autoprobe的注册

ktype的挂载十分简单,因为他是和kobject是一体的

只有这么下面一句

priv->subsys.kobj.ktype = &bus\_ktype;

这样就将bus\_ktype挂载到了platform\_bus\_type的kobject上

drivers\_autoprobe的注册如下

retval = bus\_create\_file(bus, &bus\_attr\_drivers\_autoprobe);

bus\_attr\_drivers\_autoprobe这个结构由一系列的宏进行组装

static BUS\_ATTR(drivers\_autoprobe, S\_IWUSR | S\_IRUGO,

show\_drivers\_autoprobe, store\_drivers\_autoprobe);

\#define BUS\_ATTR(\_name, \_mode, \_show, \_store)        \\

struct bus\_attribute bus\_attr\_\#\#\_name = \_\_ATTR(\_name, \_mode, \_show, \_store)

\#define \_\_ATTR(\_name,\_mode,\_show,\_store) \{ \\

.attr = \{.name = \_\_stringify(\_name), .mode = \_mode \},        \\

.show        = \_show,                                        \\

.store        = \_store,                                        \\

最后bus\_attr\_drivers\_autoprobe的模型如下

struct bus\_attribute  bus\_attr\_drivers\_autoprobe

.attr = \{

.name = “drivers\_autoprobe”,

.mode = S\_IWUSR | S\_IRUGO

\},

.show        = show\_drivers\_autoprobe,

.store        = store\_drivers\_autoprobe,

进入到bus\_create\_file中

int bus\_create\_file(struct bus\_type \*bus, struct bus\_attribute \*attr)

//参数为(bus, &bus\_attr\_drivers\_autoprobe)

int error;

if (bus\_get(bus)) \{

error = sysfs\_create\_file(&bus->p->subsys.kobj, &attr->attr);

bus\_put(bus);

\} else

error = -EINVAL;

return error;

int sysfs\_create\_file(struct kobject \* kobj, const struct attribute \* attr)

//参数为(&bus->p->subsys.kobj, &attr->attr)

BUG\_ON(!kobj || !kobj->sd || !attr);

return sysfs\_add\_file(kobj->sd, attr, SYSFS\_KOBJ\_ATTR);

int sysfs\_add\_file(struct sysfs\_dirent \*dir\_sd, const struct attribute \*attr,int type)

//参数为(&bus->p->subsys.kobj ->sd, &attr->attr, SYSFS\_KOBJ\_ATTR)

return sysfs\_add\_file\_mode(dir\_sd, attr, type, attr->mode);

int sysfs\_add\_file\_mode(struct sysfs\_dirent \*dir\_sd,

const struct attribute \*attr, int type, mode\_t amode)

//整理一下参数,现在应该为

//(&platform\_bus\_type->p->subsys.kobj ->sd, &bus\_attr\_drivers\_autoprobe->attr, SYSFS\_KOBJ\_ATTR, &bus\_attr\_drivers\_autoprobe->attr->mode)

umode\_t mode = (amode & S\_IALLUGO) | S\_IFREG;

struct sysfs\_addrm\_cxt acxt;

struct sysfs\_dirent \*sd;

int rc;

//在这一步中可以看出新建了一个节点

sd = sysfs\_new\_dirent(attr->name, mode, type);

if (!sd)

return -ENOMEM;

//这一步挂载了&bus\_attr\_drivers\_autoprobe->attr到节点中,为以后提取attr及上层结构做准备

sd->s\_attr.attr = (void \*)attr;

// dir\_sd也就是上层目录,在这里为platform\_bus\_type->p->subsys.kobj ->sd

//也就是/sys/bus/platform这个目录

sysfs\_addrm\_start(&acxt, dir\_sd);

rc = sysfs\_add\_one(&acxt, sd);

sysfs\_addrm\_finish(&acxt);

if (rc)

sysfs\_put(sd);

return rc;

struct sysfs\_dirent \*sysfs\_new\_dirent(const char \*name, umode\_t mode, int type)

char \*dup\_name = NULL;

struct sysfs\_dirent \*sd;

if (type & SYSFS\_COPY\_NAME) \{

name = dup\_name = kstrdup(name, GFP\_KERNEL);

if (!name)

return NULL;

sd = kmem\_cache\_zalloc(sysfs\_dir\_cachep, GFP\_KERNEL);

if (!sd)

goto err\_out1;

if (sysfs\_alloc\_ino(&sd->s\_ino))

goto err\_out2;

atomic\_set(&sd->s\_count, 1);

atomic\_set(&sd->s\_active, 0);

sd->s\_name = name;   //节点的名字为&bus\_attr\_drivers\_autoprobe->attr->name  也就是drivers\_autoprobe

sd->s\_mode = mode;

sd->s\_flags = type;   //节点的type为SYSFS\_KOBJ\_ATTR

return sd;

err\_out2:

kmem\_cache\_free(sysfs\_dir\_cachep, sd);

err\_out1:

kfree(dup\_name);

return NULL;

现在一切准备就绪,来看看怎么读取吧

首先是open,大概流程可以看我的另一篇文章<从文件到设备>,一直看到ext3\_lookup

这里和ext3\_lookup不同的是,sys的文件系统是sysfs文件系统,所以应该使用的lookup函数为sysfs\_lookup(/fs/sysfs/dir.c)

static struct dentry \* sysfs\_lookup(struct inode \*dir, struct dentry \*dentry,

struct nameidata \*nd)

struct dentry \*ret = NULL;

struct sysfs\_dirent \*parent\_sd = dentry->d\_parent->d\_fsdata;

struct sysfs\_dirent \*sd;

struct inode \*inode;

mutex\_lock(&sysfs\_mutex);

sd = sysfs\_find\_dirent(parent\_sd, dentry->d\_name.name);

if (!sd) \{

ret = ERR\_PTR(-ENOENT);

goto out\_unlock;

//节点的初始化在这里

inode = sysfs\_get\_inode(sd);

if (!inode) \{

ret = ERR\_PTR(-ENOMEM);

goto out\_unlock;

dentry->d\_op = &sysfs\_dentry\_ops;

dentry->d\_fsdata = sysfs\_get(sd);

d\_instantiate(dentry, inode);

d\_rehash(dentry);

out\_unlock:

mutex\_unlock(&sysfs\_mutex);

return ret;

struct inode \* sysfs\_get\_inode(struct sysfs\_dirent \*sd)

struct inode \*inode;

inode = iget\_locked(sysfs\_sb, sd->s\_ino);

if (inode && (inode->i\_state & I\_NEW))

//为节点赋值

sysfs\_init\_inode(sd, inode);

return inode;

static void sysfs\_init\_inode(struct sysfs\_dirent \*sd, struct inode \*inode)

struct bin\_attribute \*bin\_attr;

inode->i\_blocks = 0;

inode->i\_mapping->a\_ops = &sysfs\_aops;

inode->i\_mapping->backing\_dev\_info = &sysfs\_backing\_dev\_info;

inode->i\_op = &sysfs\_inode\_operations;

inode->i\_ino = sd->s\_ino;

lockdep\_set\_class(&inode->i\_mutex, &sysfs\_inode\_imutex\_key);

if (sd->s\_iattr) \{

set\_inode\_attr(inode, sd->s\_iattr);

\} else

set\_default\_inode\_attr(inode, sd->s\_mode);

//判断类型

switch (sysfs\_type(sd)) \{

case SYSFS\_DIR:

inode->i\_op = &sysfs\_dir\_inode\_operations;

inode->i\_fop = &sysfs\_dir\_operations;

inode->i\_nlink = sysfs\_count\_nlink(sd);

break;

//还记得在注册的时候有一个参数为SYSFS\_KOBJ\_ATTR赋到了sd->s\_flags上面吧

case SYSFS\_KOBJ\_ATTR:

inode->i\_size = PAGE\_SIZE;

inode->i\_fop = &sysfs\_file\_operations;

break;

case SYSFS\_KOBJ\_BIN\_ATTR:

bin\_attr = sd->s\_bin\_attr.bin\_attr;

inode->i\_size = bin\_attr->size;

inode->i\_fop = &bin\_fops;

break;

case SYSFS\_KOBJ\_LINK:

inode->i\_op = &sysfs\_symlink\_inode\_operations;

break;

default:

BUG();

unlock\_new\_inode(inode);

sysfs\_file\_operations的结构如下,之后open和read,write都明了了

const struct file\_operations sysfs\_file\_operations = \{

.read                = sysfs\_read\_file,

.write                = sysfs\_write\_file,

.llseek                = generic\_file\_llseek,

.open                = sysfs\_open\_file,

.release        = sysfs\_release,

.poll                = sysfs\_poll,

\};

有关在哪调用open还是请查阅我的另一篇文章<从文件到设备>中 nameidata\_to\_filp之后的操作

好的~  现在进入到了sysfs\_open\_file中

static int sysfs\_open\_file(struct inode \*inode, struct file \*file)

struct sysfs\_dirent \*attr\_sd = file->f\_path.dentry->d\_fsdata;

//要重的取值,在这里取得了drivers\_autoprobe的目录platform的kproject

struct kobject \*kobj = attr\_sd->s\_parent->s\_dir.kobj;

struct sysfs\_buffer \*buffer;

struct sysfs\_ops \*ops;

int error = -EACCES;

if (!sysfs\_get\_active\_two(attr\_sd))

return -ENODEV;

if (kobj->ktype && kobj->ktype->sysfs\_ops)

//这里可谓是ktype实现中的核心,在这里ops设置成了platform\_bus\_type中kobject->ktype的sysfs\_ops

ops = kobj->ktype->sysfs\_ops;

else \{

printk(KERN\_ERR "missing sysfs attribute operations for ""kobject: %s\\n", kobject\_name(kobj));

WARN\_ON(1);

goto err\_out;

if (file->f\_mode & FMODE\_WRITE) \{

if (!(inode->i\_mode & S\_IWUGO) || !ops->store)

goto err\_out;

if (file->f\_mode & FMODE\_READ) \{

if (!(inode->i\_mode & S\_IRUGO) || !ops->show)

goto err\_out;

error = -ENOMEM;

buffer = kzalloc(sizeof(struct sysfs\_buffer), GFP\_KERNEL);

if (!buffer)

goto err\_out;

mutex\_init(&buffer->mutex);

buffer->needs\_read\_fill = 1;

//然后将设置好的ops挂载到buffer上

buffer->ops = ops;

//再将buffer挂载到file->private\_data中

file->private\_data = buffer;

error = sysfs\_get\_open\_dirent(attr\_sd, buffer);

if (error)

goto err\_free;

sysfs\_put\_active\_two(attr\_sd);

return 0;

err\_free:

kfree(buffer);

err\_out:

sysfs\_put\_active\_two(attr\_sd);

return error;

现在已经为read和write操作准备好了

马上进入到read操作中  
![Image 1][]  
整个流程如上图所示,如何进入到sysfs\_read\_file在上面open的操作中已经说明了

我们就从sysfs\_read\_file开始分析(该文件在/fs/sysfs/file.c中)

sysfs\_read\_file(struct file \*file, char \_\_user \*buf, size\_t count, loff\_t \*ppos)

struct sysfs\_buffer \* buffer = file->private\_data;

ssize\_t retval = 0;

mutex\_lock(&buffer->mutex);

if (buffer->needs\_read\_fill || \*ppos == 0) \{

//主要操作在fill\_read\_buffer中

retval = fill\_read\_buffer(file->f\_path.dentry,buffer);

if (retval)

goto out;

pr\_debug("%s: count = %zd, ppos = %lld, buf = %s\\n",\_\_func\_\_, count, \*ppos, buffer->page);

retval = simple\_read\_from\_buffer(buf, count, ppos, buffer->page,

buffer->count);

out:

mutex\_unlock(&buffer->mutex);

return retval;

static int fill\_read\_buffer(struct dentry \* dentry, struct sysfs\_buffer \* buffer)

struct sysfs\_dirent \*attr\_sd = dentry->d\_fsdata;

//取得父目录的kobject,也就是platform的kobject

struct kobject \*kobj = attr\_sd->s\_parent->s\_dir.kobj;

//还记得这个buffer->ops在什么时候进行赋值的么?

struct sysfs\_ops \* ops = buffer->ops;

int ret = 0;

ssize\_t count;

if (!buffer->page)

buffer->page = (char \*) get\_zeroed\_page(GFP\_KERNEL);

if (!buffer->page)

return -ENOMEM;

if (!sysfs\_get\_active\_two(attr\_sd))

return -ENODEV;

buffer->event = atomic\_read(&attr\_sd->s\_attr.open->event);

//调用ops->show  也就是bus\_sysfs\_ops->show    具体就是bus\_attr\_show了

//参数为父目录的kobject, bus\_attr\_drivers\_autoprobe->attr,和一段char信息

count = ops->show(kobj, attr\_sd->s\_attr.attr, buffer->page);

sysfs\_put\_active\_two(attr\_sd);

if (count >= (ssize\_t)PAGE\_SIZE) \{

print\_symbol("fill\_read\_buffer: %s returned bad count\\n",

(unsigned long)ops->show);

/\* Try to struggle along \*/

count = PAGE\_SIZE - 1;

if (count >= 0) \{

buffer->needs\_read\_fill = 0;

buffer->count = count;

\} else \{

ret = count;

return ret;

现在进入bus\_attr\_show中

static ssize\_t bus\_attr\_show(struct kobject \*kobj, struct attribute \*attr,char \*buf)

//提取attr的上层结构,也就是bus\_attr\_drivers\_autoprobe

struct bus\_attribute \*bus\_attr = to\_bus\_attr(attr);

//提取kobj的上上层结构,也就是bus\_type\_private

struct bus\_type\_private \*bus\_priv = to\_bus(kobj);

ssize\_t ret = 0;

if (bus\_attr->show)

//终于到了这里,最后的调用,调用bus\_attr\_drivers\_autoprobe.show ,也就是show\_drivers\_autoprobe

//参数为bus\_priv->bus,也就是platform\_bus\_type , 及一段char信息

ret = bus\_attr->show(bus\_priv->bus, buf);

return ret;

static ssize\_t show\_drivers\_autoprobe(struct bus\_type \*bus, char \*buf)

return sprintf(buf, "%d\\n", bus->p->drivers\_autoprobe);

没什么好介绍了就是打印 buf + bus->p->drivers\_autoprobe   从结果来看~ buf是空的

到这里,终于把内核的信息给打印出来了,千辛万苦,层层调用,就是为了取得上层kobject结构,逆运算再取得kobject的上层结构

大家是否对kobject有所了解了呢?~

在对kobject进行介绍之前  还是先把write操作讲完吧 哈哈~

write操作和read操作重要的步骤基本是一致的,只不过在最后的调用中

static ssize\_t store\_drivers\_autoprobe(struct bus\_type \*bus,

const char \*buf, size\_t count)

if (buf\[0\] == '0')

bus->p->drivers\_autoprobe = 0;

else

bus->p->drivers\_autoprobe = 1;

return count;

不进行打印而对内核的参数进行了修改而已

好~ 现在让我们来看看kobject吧

kobject的结构如下

struct kobject \{

const char                \*name;          //kobject的名字

struct kref                kref;                                //kobject的原子操作

struct list\_head        entry;

struct kobject                \*parent;                        //父对象

struct kset                \*kset;                        //父容器

struct kobj\_type        \*ktype;                        //ktype

struct sysfs\_dirent        \*sd;                                //文件节点

unsigned int state\_initialized:1;

unsigned int state\_in\_sysfs:1;

unsigned int state\_add\_uevent\_sent:1;

unsigned int state\_remove\_uevent\_sent:1;

\};

kobject描述的是较具体的对象,一个设备,一个驱动,一个总线,一类设备

在层次图上可以看出,每个存在于层次图中的设备,驱动,总线,类别都有自己的kobject

kobject与kobject之间的层次由kobject中的parent指针决定

而kset指针则表明了kobject的容器

像platform\_bus 和test\_device的kset都是devices\_kset

呢parent和kset有什么不同呢

我认为是人工和默认的区别,看下面这张图 ,蓝框为kset,红框为kobject  
![Image 1][]

容器提供了一种默认的层次~  但也可以人工设置层次

对于kobject现在我只理解了这么多,欢迎大家指出有疑问的地方

最后是kset,kset比较简单,看下面的结构

struct kset \{

struct list\_head list;

spinlock\_t list\_lock;

struct kobject kobj;

struct kset\_uevent\_ops \*uevent\_ops;

\};

对于kset的描述,文档里也有介绍

/\*\*

\* struct kset - a set of kobjects of a specific type, belonging to a specific subsystem.

\* A kset defines a group of kobjects.  They can be individually

\* different "types" but overall these kobjects all want to be grouped

\* together and operated on in the same manner.  ksets are used to

\* define the attribute callbacks and other common events that happen to

\* a kobject.

翻译过来大概就是

结构kset,一个指定类型的kobject的集合,属于某一个指定的子系统

kset定义了一组kobject,它们可以是不同类型组成但却希望捆在一起有一个统一的操作

kset通常被定义为回调属性和其他通用的事件发生在kobject上

可能翻译的不是很好,望大家见谅

从结构中能看出kset比kobject多了3个属性

list\_head                                //列表

spinlock\_t                        //共享锁

kset\_uevent\_ops                //uevent操作集

list\_head        连接了所有kobject中kset属性指向自己的kobject

而kset\_uevent\_ops则用于通知机制,由于uevent的作用我也没接触过,所以暂不解析uevent的机制了

[http_blog.chinaunix.net_u1_57901_showart_1803248.html]: http://blog.chinaunix.net/u1/57901/showart_1803248.html
[Image 1]:

linux下bus、devices和platform的基础模型

发表评论取消回复

还没有评论，来说两句吧...

相关阅读

相关 Linux platform总线

相关 linux通过platform_match()匹配platform总线上的device和driver

相关 LINUX设备驱动模型之platform(平台)总线简介

相关再谈Linux下的socket编程和epoll模型

相关 Linux设备驱动模型之platform(平台)总线详解

相关在Linux环境下部署confluent platform

相关 Linux设备模型－－platform

相关 linux下bus、devices和platform的基础模型

相关 Linux Platform总线学习

相关回顾Linux下的IO模型