Linux文件系统和设备文件系统

发表于 分类于 ， ， ， 阅读次数： 本文字数： 14k 阅读时长 ≈ 13 分钟

由于字符设备和块设备都很好地体现了“一切都是文件”的设计思想，掌握Linux文件系统、设备文件系统的知识非常重要。
首先，设备驱动最终通过操作系统的文件系统调用或C库函数（本质也基于系统调用）被访问。
其次，驱动工程师在设备驱动中不可避免地会与设备文件系统打交道，如Linux2.4内核的devfs文件系统和Linux2.6内核的基于sysfs的udev文件系统。
5.1节讲解了通过Linux API和C库函数在用户空间进行Linux文件操作的编程方法。
5.2节分析了Linux文件系统的目录结构，简单介绍了Linux内核中文件系统的实现，并给出了文件系统与设备驱动的关系。
5.3节和5.4节分别讲解Linux2.4内核的devfs和Linux2.6内核所采用的udev设备文件系统，并分析了两者的区别。

5.1 Linux文件操作

5.1.1 文件操作的相关系统调用

Linux的文件操作系统调用涉及创建、打开、读写和关闭文件。

1. 创建

1
int create(const char *filename,mode_t mode);

参数mode指定新建文件的存取权限，它同umask一起决定文件的最终权限（mode&umask），其中umask代表了文件在创建时需要去掉的一些存取权限。umask可以通过系统调用umask()来改变，如下所示:

1
int umask(int newmask);

该调用将umask设置为newmask，然后返回旧的umask，它只影响读、写和执行权限。

2. 打开

1
2
int open(const cahr *pathname,int flags);
int open(const char *pathname,int flags,mode_t mode);

open()函数有两个形式，其中pathname是我们要打开的文件名（包含路径名称，默认时认为在当前路径下面），flags可以是如下表所示的一个值或者几个值的组合。
文件打开标志

标志 含义
O_RDONLY 以只读的方式打开文件
O_WRONLY 以只写的方式打开文件
O_RDWR 以读写的方式打开文件
O_APPEND 以追加的方式打开文件
O_CREAT 创建一个文件
O_EXEC 如果使用了O_CREAT而且文件已经存在，就会发生一个错误
O_NOBLOCK 以非阻塞的方式打开一个文件
O_TRUNC 如果文件已经存在，则删除文件的内容

O_RDONLY、O_WRONLY、O_RDWR这3个标志只能使用任意的一个。
如果使用了O_CREAT标志，则使用的函数是int open(const char *pathname,int flags,mode_t mode);这个时候我们还要指定mode标志，用来表示文件的访问权限。mode可以是如下表所示值的组合。
文件访问权限

标志 含义
S_IRUSR 用户可以读
S_IWUSR 用户可以写
S_IXUSR 用户可以执行
S_IRWXU 用户可以读、写、执行
S_IRGRP 组可以读
S_IWGRP 组可以写
S_IXGRP 组可以执行
S_IRWXG 组可以读、写、执行
S_IROTH 其他人可以读
S_IWOTH 其他人可以写
S_IXOTH 其他人可以执行
S_IRWXO 其他人可以读、写、执行
S_ISUID 设置用户的执行ID
S_ISGIS 设置组的执行ID

除了可以通过上述宏进行“或”逻辑产生标志之外，我们也可以自己用数字表示，Linux总共用5个数字来表示文件的各种权限：第一位表示设置用户ID；第二位表示设置组ID；第三位表示用户自己的权限位；第四位表示组的权限；第五位表示其他人的权限。每个数字可以取1（执行权限）、2（写权限）、4（读权限）、0（无）或者是这些值的和。
例如，如果要创建一个用户可读、可写、可执行，但是组没有权限，其他人可以读、可以执行的文件，并设置用户ID位。那么，应该使用的模式是1（设置用户ID）、0（不设置组ID）、7（1+2+4，读、写、执行）、0（没有权限）、5（1+4，读、执行）即10705，如下所示：

1
open("test",O_CREAT,10705);

上述语句等价于：

1
open("test",O_CREAT,S_IRWXU | S_IROTH | S_IXOTH | S_ISUID);

如果文件打开成功，open函数会返回一个文件描述符，以后对该文件的所有操作就可以通过对这个文件描述符进行操作来实现。

3. 读写

在文件打开之后，我们才可以对文件进行读写，Linux系统中提供文件读写的系统调用是read、write函数，如下所示：

1
2
int read(int fd,const void *buf,size_t length);
int write(int fd,const void *buf,size_t length);

其中参数buf为指向缓冲区的指针，length为缓冲区的大小（以字节为单位）。函数read()实现从文件描述符fd所指定的文件中读取length个字节到buf所指向的缓冲区中，返回值为实际读取的字节数。函数write实现将把length个字节从buf所指向的缓冲区写到文件描述符fd所指向的文件中，返回值为实际写入的字节数。
以O_CREAT为标志的open函数实际上实现了文件创建的功能，因此，下面的函数等同creat()函数：

1
int open(pathname,O_CREAT | O_WRONLY | O_TRUNC,mode);

4. 定位

对于随机文件，我们可以随机地指定位置读写，使用如下函数进行定位：

1
int lseek(int fd,offset_t offset,int where);

lseek()将文件读写指针相对where移动offset个字节。操作成功时，返回文件指针相对于文件头的位置。参数where可以使用如下值。
SEEK_SET：相对文件开头。
SEEK_CUR：相对文件读写指针的当前位置。
SEEK_END：相对文件末尾。
offset可取负值，例如下述调用可将文件指针相对当前位置向前移动5个字节。

1
lseek(fd,-5,SEEK_CUR);

由于lseek()函数的返回值为文件指针相对于文件头的位置，因此下列调用的返回值就是文件的长度：

1
lseek(fd,0,SEEK_END);

5. 关闭

当操作完成之后，就要关闭文件了，只要调用close函数就可以了，其中fd是要关闭的文件描述符。

1
int close(int fd);

例程：编写一个程序，在当前目录中创建用户可读写文件“hello.txt”，在其中写入“Hello，software weekly”，关闭该文件。再次打开该文件，读取其中的内容并输出在屏幕上，代码如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <stdio.h>
#define LENGTH 100

int main()
{
    int fd,len;
    char str[LENGTH];

    fd = open("hello.txt",O_CREAT | O_RDWR,S_IRUSR | S_IWUSR);
    if(fd)
    {
        write(fd,"Hello World",strlen("Hello World"));
        close(fd);
    }

    fd = open("hello.txt",O_RDWR);
    len = read(fd,str,LENGTH);
    str[len] = '\0';
    printf("%s\n",str);
    close(fd);
}

编译并运行，执行结果为输出“Hello World”。

5.1.2 C库函数的文件操作

C库函数的文件操作实际上是独立于具体的操作系统平台的，不管是在DOS、Windows、Linux还是Vxworks中都是这些函数。

1. 创建和打开

1
FILE *fopen(const char *path,const char *mode);

fopen()实现打开指定文件filename，其中的mode为打开模式，C库函数中支持的打开模式如下表所示。
C库函数文件打开标志

标志 含义
r、rb 以只读方式打开
w、wb 以只写方式打开。如果文件不存在，则创建该文件，否则文件被截断
a、ab 以追加方式打开。如果文件不存在，则创建该文件
r+、r+b、rb+ 以读写方式打开
w+、W+b、wb+ 以读写方式打开。如果文件不存在，则创建新文件，否则文件被截断
a+、a+b、ab+ 以读和追加方式打开。如果文件不存在，则创建新文件

其中b用于区分二进制文件和文本文件，这一点在DOS、Windows系统中是有区分的，但是Linux系统不区分二进制和文本文件。

2. 读写

C库函数支持以字符、字符串等为单位，支持按照某种格式进行文件的读写，这一组函数为：

1
2
3
4
5
6
7
8
int fgetc(FILE *stream);
int fputc(int c,FILE *stream);
char *fgets(char *s,int n,FILE *stream);
int fputs(const char *s,FILE *stream);
int fprintf(FILE *stream,const char *format,...);
int fscanf(FILE *stream,const char *format,...);
size_t fread(void *ptr,size_t size,size_t n,FILE *stream);
size_t fwrite(const void *ptr,size_t size,size_t size,FILE *stream);

fread()实现从stream中读取n个字段，每个字段为size个字节，并将读取的字段放入ptr所指的字符数组中，返回实际已读取的字段数。在读取的字段数小于num时，可能是在函数调用时出现错误，也可能是读到文件的结尾。所以要通过调用feof()和ferror()来判断。
write()实现从缓冲区ptr所指的数组中把n个字段写到stream中，每个字段长为size个字节，返回实际写入的字段数。
另外，C库函数还提供了读写过程中的定位能力，这些函数包括：

1
2
3
int fgetpos(FILE *stream,fpos_t *pos);
int fsetpos(FILE *stream,const fpos_t *pos);
int fseek(FILE *stream,long offset,int where);

3. 关闭

利用C库函数关闭文件依然是很简单的操作，如下所示：

1
int fclose(FILE *stream);

例程：将第5.1.1节中的例程用C库函数来实现，如下所示：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <stdio.h>
#define LENGTH 100

int main()
{
    FILE *fd;
    char str[LENGTH];

    fd = fopen("hello.txt","w+");
    if(fd)
    {
        fputs("Hello World",fd);
        fclose(fd);
    }

    fd = fopen("hello.txt","r");
    fgets(str,LENGTH,fd);
    printf("%s\n",str);
    fclose(fd);
}

5.2 Linux文件系统

5.2.1 Linux文件系统目录结构

进入Linux根目录，运行“ls -l”命令，可以看到Linux系统包含以下目录。

1. /bin

包含基本命令，如ls、cp、mkdir等，这个目录中的文件都是可执行的。

2. /boot

Linux系统的内核及引导系统程序所需要的文件，如vmlinux、initrd.img文件都位于这个目录中。

3. /dev

设备文件存储目录，应用程序通过对这些文件的读写和控制就可以访问实际的设备。

4. /etc

系统配置文件的所在地，一些服务器的配置文件也在这里，如用户账号及密码配置文件。

5. /home

普通用户的家目录

6. /lib

库文件存放目录

7. /lost+found

在Ext2或Ext3文件系统中，当系统意外崩溃或机器意外关机时会产生一些文件碎片放在这里。

8. /mnt

/mnt这个目录一般是用于存放挂载存储设备的挂载目录的，比如有cdrom等目录，可以参看/etc/fstab的定义。有时我们可以把让系统开机自动挂载文件系统，把挂载点放在这里也是可以的。

9. /opt

opt是“可选”的意思，有些软件包会被安装在这里，用户自己编译的软件包也可以安装在这个目录中.

10. /proc

操作系统运行时，进程及内核信息（CPU、硬盘分区、内存信息等）存放在这里。/proc目录为伪文件系统proc的挂载目录，proc并不是真正的文件系统，它存在于内存之中。

11. /root

Linux超级权限用户root的家目录。

12. /sbin

存放可执行文件，大多是涉及系统管理的命令，是超级权限用户root的可执行命令存放地，普通用户无权限执行这个目录下的命令，这个目录和/usr/sbin；/usr/local/sbin目录是相似的。

13. /tmp

有时用户运行程序的时候会产生临时文件，/tmp用来存放临时文件。

14. /usr

这个是系统存放程序的目录，比如命令、帮助文件等，它包含很多文件和目录，Linux发行版提供的软件包大多被安装在这里。

15. /var

var表示的是变化的意思，这个目录的内容经常变动，如/var的/var/log目录被用来存放系统日志。

16. /sys

Linux2.6内核所支持的sysfs文件系统被映射在此目录。Linux设备驱动模型中的总线、驱动和设备都可以在sysfs文件系统中找到对应的节点。当内核检测到系统中出现新设备后，内核会在sysfs文件系统中为该设备生成一项新的记录。

17. /initrd

若在启动过程中使用了initrd映像作为临时根文件系统，则在执行完其上的/linuxrc挂接真正的根文件系统后，原来的初始RAM文件系统被映射到/initrd目录。

5.2.2 Linux文件系统与设备驱动

下图所示为Linux系统中虚拟文件系统、磁盘文件（存放于RamDisk、Flash、ROM、SD卡、U盘等文件系统中的文件也属于磁盘文件）及一般的设备文件与设备驱动程序之间的关系。
img not found
应用程序和VFS之间的接口是系统调用，而VFS与磁盘文件系统以及普通设备之间的接口是file_operations结构体成员函数，这个结构体包含对文件进行打开、关闭、读写、控制的一系列成员函数。
由于字符设备的上层没有磁盘文件系统，所以字符设备的file_operations成员函数就直接有设备驱动提供了，file_operations正是字符设备驱动的核心。
而对于块存储设备而言，ext2、fat、jffs2等文件系统中会实现针对VFS的file_operations成员函数，设备驱动层将看不到file_operations的存在。磁盘文件系统和设备驱动会将对磁盘上文件的访问最终转换成对磁盘上柱面和扇区的访问。
在设备驱动程序的设计中，一般而言，会关心结构体file和inode这两个结构体。

1. file结构体

文件结构代表一个打开的文件（设备对应于设备文件），系统中每个打开的文件在内核空间都有一个关联的struct file。它由内核在打开文件时创建m并传递给在文件上进行操作的任何函数。在文件的所有实例都关闭后，内核释放这个数据结构。在内核和驱动源代码中，struct file的指针通常被命名为file或filp（file pointer）。代码如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
struct file {
	union {
		struct list_head				fu_list;//文件对象链表
		struct rcu_head 				fu_rcuhead;//释放之后的RCU链表
	} f_u;
	struct path							f_path;//包含目录项
	const struct file_operations		*f_op;//文件操作表
	spinlock_t							f_lock;//单个文件结构锁
	atomic_t							f_count;//文件对象的使用计数
	unsigned int						f_flags;//当文件打开时所指定的标志
	mode_t								f_mode;//文件的访问模式
	loff_t								f_pos;//文件当前的位移量（文件指针）
	struct fown_struct					f_owner;//拥有者通过信号进行异步I/O数据的传送
	const struct cred					*f_cred;//文件的信任状态
	struct file_ra_state				f_ra;//预读状态
	unsigned long						f_version;//版本号
	void								*f_security;//安全模块
	void								*private_data;//tty设备驱动的钩子
	struct list_head					f_ep_links;//事件池链表
	spinlock_t							f_ep_lock;//事件池锁
	struct address_space				*f_mapping;//页缓存映射
	unsigned long						f_mnt_write_state;//调试状态
};

文件读/写模式mode、标志f_flags都是设备驱动关心的内容，而私有数据指针private_data在设备驱动中被广泛应用，大多被指向设备驱动自定义用于描述设备的结构体。
驱动程序中经常会使用如下类似的代码来检测用户打开文件的读写方式。

1
2
3
4
5
6
7
8
if(file->f_mode & FMODE_WRITE)//用户要求可写
{

}
if(file->f_mode & FMODE_READ)//用户要求可读
{

}

下面的代码可用于判断以阻塞还是非阻塞方式打开设备文件。

1
2
3
4
if(file->f_flags & O_NONBLOCK)//非阻塞
    pr_debug("open: non-blocking\n");
else//阻塞
    pr_debug("open: blocking\n");

2. inode结构体

VFS inode包含文件访问权限、属主、组、大小、生成时间、访问时间、最后修改时间等信息。它是Linux管理文件系统的最基本单位，也是文件系统连接任何子目录、文件的桥梁，inode结构体的定义如下所示。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
struct inode {
    ...
    imode_t             i_mode;//inode的权限
	uid_t			    i_uid;//inode拥有者的id
	gid_t			    i_gid;//inode所属的群组id
	dev_t			    i_rdev;//若是设备文件，此字段将记录设备的设备号
	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在做I/O时的区块大小
    unsigned long       i_blocks;//inode所使用的block数，一个block为512byte

    struct block_device	*i_bdev;//若是块设备，为其对应的block_device结构体指针
    struct cdev		    *i_cdev;//若是字符设备，为其对应的cdev结构体指针
    ...
};

对于表示设备文件的inode结构，i_rdev字段包含设备编号。Linux2.6设备编号分为主设备编号和次设备编号，前者为dev_t的高12位，后者为dev_t的低20位。下列操作用于从一个inode中获得主设备号和次设备号。

1
2
unsigned int iminor(struct inode *inode);
unsigned int imajor(struct inode *inode);

查看/proc/devices文件可以获知系统中注册的设备，第一列为主设备号，第二列为设备名，如下图所示。
img not found
查看/dev目录可以获知系统中包含的设备文件，日期的前两列给出了对应设备的主设备号和次设备号，如下所示：

1
2
crw-rw----  1   root    uucp    4,  64  Jan 30  2003    /dev/ttyS0
brw-rw----  1   root    disk    8,   0  Jan 30  2003    /dev/sda

主设备号是与驱动对应的概念，同一类设备一般使用相同的主设备号，不同类的设备一般使用不同的主设备号。因为同一驱动可支持多个同类设备，因此用次设备号来描述使用该驱动的设备的序号，序号一般从0开始。
内核Documents目录下的devices.txt文件描述了Linux设备号的分配情况，需要注意的是，设备号标志并不是硬性规定，在具体的设备驱动程序中，尽管一般会遵循，但是也可以有例外。

5.3 devfs设备文件系统

devfs（设备文件系统）是由Linux2.4内核引入的，引入时被许多工程师给予了高度评价，它的出现使得设备驱动程序能自主地管理它自己的设备文件。具体来说，devfs具有如下优点。

  1. 可以通过程序在设备初始化时在/dev目录下创建设备文件，卸载设备时将它删除。
  2. 设备驱动程序可以指定设备名、所有者和权限位，用户空间程序仍可以修改所有者和权限位。
  3. 不再需要为设备驱动程序分配主设备号以及处理次设备号，在程序中可以直接给register_chrdev()传递0主设备号以动态获得可用的主设备号，并在devfs_register()中指定次设备号。

驱动程序应调用下面这些函数来进行设备文件的创建和删除工作。

1
2
3
4
5
6
7
//创建设备目录
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);

在Linux2.4的设备驱动编程中，分别在模块加载和卸载函数中创建和撤销设备文件是被普遍采用并值得大力推荐的好方法。下列代码给出了一个使用devfs的例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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_chrdev(XXX_MAJOR,DEVICE_NAME);//注销设备
}

module_init(xxx_init);
module_exit(xxx_exit);

代码中第7行和第25行分别用于注册和注销字符设备，使用的register_chrdev()和unregister_chrdev()在Linux2.6内核中虽然仍然被支持，但是是过时的做法。第15行和第24行分别用于创建和删除devfs文件节点。

5.4 udev设备文件系统

5.4.1 udev与devfs的区别

尽管devfs有这样和那样的优点，但是，在Linux2.6内核中，devfs被认为是过时的方法，并最终被抛弃，udev取代了它。Linux VFS维护者Al Viro指出了udev取代devfs的几点原因：

  1. devfs所做的工作被确信可以在用户态完成。
  2. 一些bug相当长的时间内未被修复。
  3. devfs的维护者和作者停止了对代码的维护工作。

udev完全在用户态工作，利用设备加入或移除时内核所发送的热插拔事件（hotplug event）来工作。在热插拔时，设备的详细信息会由内核输出到位于/sys的sysfs文件系统。udev的设备命名策略、权限控制和事件处理都是在用户态下完成的，它利用sysfs中的信息来进行创建设备文件节点等工作。
由于udev根据系统中硬件设备的状态动态更新设备文件，进行设备文件的创建和删除等，因此，在使用udev后，/dev目录下就会只包含系统中真正存在的设备了。
devfs与udev的另一个显著区别在于：采用devfs，当一个并不存在的/dev节点被打开的时候，devfs能自动加载对应的驱动，而udev不能。这是因为udev的设计者认为Linux应该在设备被发现的时候加载驱动模块，而不是当它被访问的时候。udev的设计者认为devfs所提供的打开/dev节点时自动加载驱动的功能对于一个配置正确的计算机是多余的。系统中所有的设备都应该产生热插拔事件并加载恰当的驱动，而udev能注意到这点并且为它创建对应的设备节点。

5.4.2 sysfs文件系统与Linux设备模型

1. sysfs文件系统

Linux2.6内核引入了sysfs文件系统，sysfs被看成是与proc、devfs和devpty同类别的文件系统，该文件系统是一个虚拟的文件系统，它可以产生一个包括所有系统硬件的层级视图，与提供进程和状态信息的proc文件系统十分类似。
sysfs把连接在系统上的设备和总线组织成为一个分级的文件，它们可以有用户空间存取，向用户空间导出的内核数据结构以及它们的属性。sysfs的一个目的就是展示设备驱动模型中各组件的层次关系，其顶级目录包括block、device、bus、drivers、class、power和firmware。
block目录包含所有的块设备，devices目录包含系统所有的设备并根据设备挂接的总线类型组织成层次结构，bus目录包含系统中所有的总线类型，drivers目录包含内核中所有已注册的设备驱动程序，class目录包含系统中的设备类型（如网卡设备、声卡设备、输入设备等）。在/sys目录运行tree会得到一个相当长的树形目录，下面摘取一部分：
img not found
在/sys/bus的pci等子目录下，又会在分出drivers和devices目录，而devices目录中的文件是对/sys/devices目录中文件的符号链接。同样的，/sys/class目录下包含许多对/sys/devices下文件的链接。如下图所示，这与设备、驱动、总线和类的现实情况是直接对应的，也正符合Linux2.6内核的设备模型。
img not found
随着技术的不断进步，系统的拓扑结构越来越复杂，对智能电源管理、热插拔以及即插即用的支持要求也越来越高，Linux2.4已经难以满足这些需求。为适应这种形势的需要，Linux2.6内核开发了上述全新的设备、总线、类和驱动环环相扣的设备模型。下图也形象地表示了Linux驱动模型中设备、总线和类之间的关系。
img not found
大多数情况下，Linux2.6内核中的设备模型代码会处理好这些关系，内核中的总线级和其他内核子系统会完成与设备模型的交互，这使得驱动工程师几乎不需要关心设备模型。但是，理解Linux设备模型的实现机制对驱动工程师仍然是大有裨益的，具体而言，内核将借助下文将介绍的kobject、kset、subsystem、bus_type、device、device_driver、class、class_device、class_interface等重量级数据结构来完成设备模型的架构。

2. kobject内核对象

kobject是Linux2.6引入的设备管理机制，在内核中由kobject结构体表示，这个数据结构使所有设备在底层都具有统一的接口。kobject提供了基本的对象管理能力，是构成Linux2.6 设备模型的核心结构，每个在内核中注册的kobject对象都对应于sysfs文件系统中的一个目录。kobject结构体的定义如代码清单所示。

1
2
3
4
5
6
7
8
9
10
struct kobjetc{
    char *k_name;
    char name[KOBJ_NAME_LEN];//对象名称
    struct kref kref;//对象应用计数
    struct list_head entry;//用于挂接该object对象到kset链表
    struct kobject *parent;//指向父对象的指针
    struct kset *kset;//所属kset的指针
    struct kobj_type *ktype;//指向对象类型描述符的指针
    struct dentry *dentry;//sysfs文件系统中与该对象对应的文件节点入口
};

内核通过kobject的kref成员实现对象引用计数管理，且提供两个函数kobject_get()、kobject_put()分别用于增加和减少引用计数，当引用计数为0时，所有使用该对象的资源将被释放。
kobject的ktype成员是一个指向kobj_type结构的指针，表示该对象的类型。kobj_type数据结构包含3个成员：用于释放kobject占用的资源的的release()函数、指向sysfs操作的sysfs_ops指针和sysfs文件系统默认属性列表。如以下代码所示：

1
2
3
4
5
struct kobj_type{
    void (*release)(struct kobject *);//release函数
    struct sysfs_ops *sysfs_ops;//属性操作
    struct attribute **default_attrs;//默认属性    
};

kobject_type结构体中的sysfs_ops包括store()和show()两个成员函数，用于实现属性的读写，代码清单给出了sysfs_ops结构体的定义。当从用户空间读取属性时，show函数将被调用，该函数将指定属性值存入buffer中返回给用户，而socket函数用于存储用户通过buffer传入的属性值。和kobject不同的是，属性在sysfs中呈现为一个文件，而kobject则呈现为sysfs中的目录。

1
2
3
4
struct sysfs_ops{
    ssize_t (*show)(struct kobject *,struct attribute *,char *);
    ssize_t (*store)(struct kobject *,struct attribute *,const char *,size_t );
};

Linux内核中提供了一系列操作kobject的函数:

1
void kobject_init(struct kobject *kobj);

该函数用于初始化kobject，它设置kobject引用计数为1，entry域指向自身，其所属kset引用计数加1。

1
int kobject_set_name(struct kobject *kobj,const char name,...);

该函数用于设置指定kobject的名称。

1
void kobject_cleanup(struct kobject *kobj); and void kobject_release(struct kref *kref);

该函数用于清除kobject，当其引用计数为0时，释放对象占用的资源。

1
struct kobject *kobject_get(struct kobject *kobj);

该函数用于将kobj对象的引用计数加1，同时返回该对象的指针。

1
void kobject_put(struct kobject *kobj);

该函数用于将kobj对象的引用计数减1，如果引用计数降为0，则调用kobject_release()释放该kobject对象。

1
int kobject_add(struct kobject *kobj);

该函数用于将kobject对象加入到Linux设备层次，它会挂接该kobject对象到kset的list链中，增加父目录各级kobject的引用计数，在其parent指向的目录下创建文件节点，并启动该类型内核对象的hotplug函数。

1
int kobject_register(struct kobject *kobj);

该函数用于注册kobject，它会先调用kobject_init()初始化kobj，再调用kobject_add()完成该内核对象的添加。

1
void kobject_del(struct kobject *kobj);

这个函数是kobject_add()的反函数，它从Linux设备层次(hierarchy)中删除kobject对象。

1
void kobject_unregister(struct kobject *kobj);

这个函数是kobject_register()的反函数，用于注销kobject。与kobject_register()相反，它首先调用kobject_del()从设备层次中删除该对象，再调用kobject_put()减少该对象的引用计数，如果引用计数降为0，则释放该kobject对象。

3. kset 内核对象集合