之前我們分析了引用計數kref，總結了sysfs提供的API，並翻譯了介紹kobject原理及用法的文檔。應該說準備工作做得足夠多，kobject的實現怎麼都可以看懂了，甚至只需要總結下API就行了。可我還是決定把kobject的實現代碼從頭分析一遍。一是因爲kobject的代碼很重要，會在設備驅動模型代碼中無數次被用到，如果不熟悉的話可以說是舉步維艱。二是爲了熟悉linux的編碼風格，爲以後分析更大規模的代碼奠定基礎。
kobject的頭文件在include/linux/kobject.h，實現在lib/kobject.c。閒話少說，上代碼。
struct kobject {
const char *name;
struct list_head entry;
struct kobject *parent;
struct kset *kset;
struct kobj_type *ktype;
struct sysfs_dirent *sd;
struct kref kref;
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;
unsigned int uevent_suppress:1;
};在struct kobject中，name是名字，entry是用於kobject所屬kset下的子kobject鏈表，parent指向kobject的父節點，kset指向kobject所屬的kset，ktype定義了kobject所屬的類型，sd指向kobject對應的sysfs目錄，kref記錄kobject的引用計數，之後是一系列標誌。
struct kobj_type {
void (*release)(struct kobject *kobj);
struct sysfs_ops *sysfs_ops;
struct attribute **default_attrs;
};struct kobj_type就是定義了kobject的公共類型，其中既有操作的函數，也有公共的屬性。其中release()是在kobject釋放時調用的，sysfs_ops中定義了讀寫屬性文件時調用的函數。default_attrs中定義了這類kobject公共的屬性。
struct kset {
struct list_head list;
spinlock_t list_lock;
struct kobject kobj;
struct kset_uevent_ops *uevent_ops;
};struct kset可以看成在kobject上的擴展，它包含一個kobject的鏈表，可以方便地表示sysfs中目錄與子目錄的關係。其中，list是所屬kobject的鏈表頭，list_lock用於在訪問鏈表時加鎖，kobj是kset的內部kobject，要表現爲sysfs中的目錄就必須擁有kobject的功能，最後的kset_uevent_ops定義了對發往用戶空間的uevent的處理。我對uevent不瞭解，會盡量忽略。
struct kobj_attribute {
struct attribute attr;
ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
char *buf);
ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
const char *buf, size_t count);
};
struct kobj_attribute是kobject在attribute上做出的擴展，添加了兩個專門讀寫kobject屬性的函數。無論是kobject，還是kset（說到底是kset內部的kobject），都提供了使用kobj_attribute的快速創建方法。
結構差不多介紹完了，下面看看實現。我所知道的代碼分析風格，喜歡自頂向下的方式，從一個函數開始，介紹出一個函數調用樹。在代碼量很大，涉及調用層次很深的時候，確實要採用這種打洞的方式來尋找突破口。但這種自頂向下的方式有兩個問題：一是很容易迷失，二是代碼分析的難度會逐漸增大而不是減小。在茫茫的代碼中，你一頭下去，周圍都是你不認識的函數，一個函數裏調用了三個陌生的函數，其中一個陌生的函數又調用了五個更陌生的函數...不久你就會產生很強的挫敗感。這就像走在沙漠上，你不知道終點在哪，也許翻過一個沙丘就到了，也許還有無數個沙丘。而且在這種分析時，人是逐漸走向細節，容易被細節所困擾，忽略了整體的印象與代碼的層次感。所以，我覺得在分析代碼時，也可以採用自底向上的方式，從細小的、內部使用的函數，到比較宏觀的、供外部調用的函數。而且按照這種順序來看代碼，基本就是文件從頭讀到尾的順序，也比較符合寫代碼的流程。linux代碼喜歡在文件開始處攢內部靜態函數，攢到一定程度爆發，突然實現幾個外部API，然後再攢，再實現。而且之前的內部靜態函數會反覆調用到。linux代碼寫得很有層次感，除了內外有別，還把意思相近的，或者功能剛好相反的，或者使用時順序調用的函數放在一起，很便於閱讀。閒話少說，等你看完kobject的實現自然就清楚了。
static int populate_dir(struct kobject *kobj)
{
struct kobj_type *t = get_ktype(kobj);
struct attribute *attr;
int error = 0;
int i;
if (t && t->default_attrs) {
for (i = 0; (attr = t->default_attrs[i]) != NULL; i++) {
error = sysfs_create_file(kobj, attr);
if (error)
break;
}
}
return error;
}
static int create_dir(struct kobject *kobj)
{
int error = 0;
if (kobject_name(kobj)) {
error = sysfs_create_dir(kobj);
if (!error) {
error = populate_dir(kobj);
if (error)
sysfs_remove_dir(kobj);
}
}
return error;
}create_dir()在sysfs中創建kobj對應的目錄，populate_dir()創建kobj中默認屬性對應的文件。create_dir()正是調用populate_dir()實現的。
static int get_kobj_path_length(struct kobject *kobj)
{
int length = 1;
struct kobject *parent = kobj;
/* walk up the ancestors until we hit the one pointing to the
* root.
* Add 1 to strlen for leading '/' of each level.
*/
do {
if (kobject_name(parent) == NULL)
return 0;
length += strlen(kobject_name(parent)) + 1;
parent = parent->parent;
} while (parent);
return length;
}
static void fill_kobj_path(struct kobject *kobj, char *path, int length)
{
struct kobject *parent;
--length;
for (parent = kobj; parent; parent = parent->parent) {
int cur = strlen(kobject_name(parent));
/* back up enough to print this name with '/' */
length -= cur;
strncpy(path + length, kobject_name(parent), cur);
*(path + --length) = '/';
}
pr_debug("kobject: '%s' (%p): %s: path = '%s'\n", kobject_name(kobj),
kobj, __func__, path);
}
/**
* kobject_get_path - generate and return the path associated with a given kobj and kset pair.
*
* @kobj: kobject in question, with which to build the path
* @gfp_mask: the allocation type used to allocate the path
*
* The result must be freed by the caller with kfree().
*/
char *kobject_get_path(struct kobject *kobj, gfp_t gfp_mask)
{
char *path;
int len;
len = get_kobj_path_length(kobj);
if (len == 0)
return NULL;
path = kzalloc(len, gfp_mask);
if (!path)
return NULL;
fill_kobj_path(kobj, path, len);
return path;
}
前面兩個是內部函數，get_kobj_path_length()獲得kobj路徑名的長度，fill_kobj_path()把kobj路徑名填充到path緩衝區中。
kobject_get_path()靠兩個函數獲得kobj的路徑名，從攢函數到爆發一氣呵成。
static void kobj_kset_join(struct kobject *kobj)
{
if (!kobj->kset)
return;
kset_get(kobj->kset);
spin_lock(&kobj->kset->list_lock);
list_add_tail(&kobj->entry, &kobj->kset->list);
spin_unlock(&kobj->kset->list_lock);
}
/* remove the kobject from its kset's list */
static void kobj_kset_leave(struct kobject *kobj)
{
if (!kobj->kset)
return;
spin_lock(&kobj->kset->list_lock);
list_del_init(&kobj->entry);
spin_unlock(&kobj->kset->list_lock);
kset_put(kobj->kset);
}
kobj_kset_join()把kobj加入kobj->kset的鏈表中，kobj_kset_leave()把kobj從kobj->kset的鏈表中去除，兩者功能相對。
static void kobject_init_internal(struct kobject *kobj)
{
if (!kobj)
return;
kref_init(&kobj->kref);
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;
}
static int kobject_add_internal(struct kobject *kobj)
{
int error = 0;
struct kobject *parent;
if (!kobj)
return -ENOENT;
if (!kobj->name || !kobj->name[0]) {
WARN(1, "kobject: (%p): attempted to be registered with empty "
"name!\n", kobj);
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) {
if (!parent)
parent = kobject_get(&kobj->kset->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;
/* be noisy on error issues */
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;
}
kobject_init_internal()初始化kobj。
kobject_add_internal()把kobj加入已有的結構。
這兩個函數看似無關，實際很有關係。在kobject中有好幾個結構變量，但重要的只有兩個，一個是kset，一個是parent。這兩個都是表示當前kobject在整個體系中的位置，決不能自行決定，需要外部參與設置。那把kobject創建的過程分爲init和add兩個階段也就很好理解了。kobject_init_internal()把一些能自動初始化的結構變量初始化掉，等外界設置了parent和kset，再調用kobject_add_internal()把kobject安在適當的位置，並創建相應的sysfs目錄及文件。
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
va_list vargs)
{
const char *old_name = kobj->name;
char *s;
if (kobj->name && !fmt)
return 0;
kobj->name = kvasprintf(GFP_KERNEL, fmt, vargs);
if (!kobj->name)
return -ENOMEM;
/* ewww... some of these buggers have '/' in the name ... */
while ((s = strchr(kobj->name, '/')))
s[0] = '!';
kfree(old_name);
return 0;
}
/**
* kobject_set_name - Set the name of a kobject
* @kobj: struct kobject to set the name of
* @fmt: format string used to build the name
*
* This sets the name of the kobject. If you have already added the
* kobject to the system, you must call kobject_rename() in order to
* change the name of the kobject.
*/
int kobject_set_name(struct kobject *kobj, const char *fmt, ...)
{
va_list vargs;
int retval;
va_start(vargs, fmt);
retval = kobject_set_name_vargs(kobj, fmt, vargs);
va_end(vargs);
return retval;
}
kobject_set_name()是設置kobj名稱的，它又調用kobject_set_name_vargs()實現。但要注意，這個kobject_set_name()僅限於kobject添加到體系之前，因爲它只是修改了名字，並未通知用戶空間。
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) {
/* do not error out as sometimes we can recover */
printk(KERN_ERR "kobject (%p): tried to init an initialized "
"object, something is seriously wrong.\n", kobj);
dump_stack();
}
kobject_init_internal(kobj);
kobj->ktype = ktype;
return;
error:
printk(KERN_ERR "kobject (%p): %s\n", kobj, err_str);
dump_stack();
}kobject_init()就是調用kobject_init_internal()自動初始化了一些結構變量，然後又設置了ktype。其實這個ktype主要是管理一些默認屬性什麼的，只要在kobject_add_internal()調用create_dir()之前設置就行，之所以會出現在kobject_init()中，完全是爲了與後面的kobject_create()相對比。
static int kobject_add_varg(struct kobject *kobj, struct kobject *parent,
const char *fmt, va_list vargs)
{
int retval;
retval = kobject_set_name_vargs(kobj, fmt, vargs);
if (retval) {
printk(KERN_ERR "kobject: can not set name properly!\n");
return retval;
}
kobj->parent = parent;
return kobject_add_internal(kobj);
}
/**
* kobject_add - the main kobject add function
* @kobj: the kobject to add
* @parent: pointer to the parent of the kobject.
* @fmt: format to name the kobject with.
*
* The kobject name is set and added to the kobject hierarchy in this
* function.
*
* If @parent is set, then the parent of the @kobj will be set to it.
* If @parent is NULL, then the parent of the @kobj will be set to the
* kobject associted with the kset assigned to this kobject. If no kset
* is assigned to the kobject, then the kobject will be located in the
* root of the sysfs tree.
*
* If this function returns an error, kobject_put() must be called to
* properly clean up the memory associated with the object.
* Under no instance should the kobject that is passed to this function
* be directly freed with a call to kfree(), that can leak memory.
*
* Note, no "add" uevent will be created with this call, the caller should set
* up all of the necessary sysfs files for the object and then call
* kobject_uevent() with the UEVENT_ADD parameter to ensure that
* userspace is properly notified of this kobject's creation.
*/
int kobject_add(struct kobject *kobj, struct kobject *parent,
const char *fmt, ...)
{
va_list args;
int retval;
if (!kobj)
return -EINVAL;
if (!kobj->state_initialized) {
printk(KERN_ERR "kobject '%s' (%p): tried to add an "
"uninitialized object, something is seriously wrong.\n",
kobject_name(kobj), kobj);
dump_stack();
return -EINVAL;
}
va_start(args, fmt);
retval = kobject_add_varg(kobj, parent, fmt, args);
va_end(args);
return retval;
}kobject_add()把kobj添加到體系中。但它還有一個附加功能，設置kobj的名字。parent也是作爲參數傳進來的，至於爲什麼kset沒有同樣傳進來，或許是歷史遺留原因吧。
int kobject_init_and_add(struct kobject *kobj, struct kobj_type *ktype,
struct kobject *parent, const char *fmt, ...)
{
va_list args;
int retval;
kobject_init(kobj, ktype);
va_start(args, fmt);
retval = kobject_add_varg(kobj, parent, fmt, args);
va_end(args);
return retval;
}kobject_init_and_add()雖然是kobject_init()和kobject_add()的合併，但並不常用，因爲其中根本沒留下設置kset的空擋，這無疑不太合適。
int kobject_rename(struct kobject *kobj, const char *new_name)
{
int error = 0;
const char *devpath = NULL;
const char *dup_name = NULL, *name;
char *devpath_string = NULL;
char *envp[2];
kobj = kobject_get(kobj);
if (!kobj)
return -EINVAL;
if (!kobj->parent)
return -EINVAL;
devpath = kobject_get_path(kobj, GFP_KERNEL);
if (!devpath) {
error = -ENOMEM;
goto out;
}
devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
if (!devpath_string) {
error = -ENOMEM;
goto out;
}
sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
envp[0] = devpath_string;
envp[1] = NULL;
name = dup_name = kstrdup(new_name, GFP_KERNEL);
if (!name) {
error = -ENOMEM;
goto out;
}
error = sysfs_rename_dir(kobj, new_name);
if (error)
goto out;
/* Install the new kobject name */
dup_name = kobj->name;
kobj->name = name;
/* This function is mostly/only used for network interface.
* Some hotplug package track interfaces by their name and
* therefore want to know when the name is changed by the user. */
kobject_uevent_env(kobj, KOBJ_MOVE, envp);
out:
kfree(dup_name);
kfree(devpath_string);
kfree(devpath);
kobject_put(kobj);
return error;
}kobject_rename()就是在kobj已經添加到系統之後，要改名字時調用的函數。它除了完成kobject_set_name()的功能，還向用戶空間通知這一消息。
int kobject_move(struct kobject *kobj, struct kobject *new_parent)
{
int error;
struct kobject *old_parent;
const char *devpath = NULL;
char *devpath_string = NULL;
char *envp[2];
kobj = kobject_get(kobj);
if (!kobj)
return -EINVAL;
new_parent = kobject_get(new_parent);
if (!new_parent) {
if (kobj->kset)
new_parent = kobject_get(&kobj->kset->kobj);
}
/* old object path */
devpath = kobject_get_path(kobj, GFP_KERNEL);
if (!devpath) {
error = -ENOMEM;
goto out;
}
devpath_string = kmalloc(strlen(devpath) + 15, GFP_KERNEL);
if (!devpath_string) {
error = -ENOMEM;
goto out;
}
sprintf(devpath_string, "DEVPATH_OLD=%s", devpath);
envp[0] = devpath_string;
envp[1] = NULL;
error = sysfs_move_dir(kobj, new_parent);
if (error)
goto out;
old_parent = kobj->parent;
kobj->parent = new_parent;
new_parent = NULL;
kobject_put(old_parent);
kobject_uevent_env(kobj, KOBJ_MOVE, envp);
out:
kobject_put(new_parent);
kobject_put(kobj);
kfree(devpath_string);
kfree(devpath);
return error;
}kobject_move()則是在kobj添加到系統後，想移動到新的parent kobject下所調用的函數。在通知用戶空間上，與kobject_rename()調用的是同一操作。
void kobject_del(struct kobject *kobj)
{
if (!kobj)
return;
sysfs_remove_dir(kobj);
kobj->state_in_sysfs = 0;
kobj_kset_leave(kobj);
kobject_put(kobj->parent);
kobj->parent = NULL;
}kobject_del()僅僅是把kobj從系統中退出，相對於kobject_add()操作。
/**
* kobject_get - increment refcount for object.
* @kobj: object.
*/
struct kobject *kobject_get(struct kobject *kobj)
{
if (kobj)
kref_get(&kobj->kref);
return kobj;
}
/*
* kobject_cleanup - free kobject resources.
* @kobj: object to cleanup
*/
static void kobject_cleanup(struct kobject *kobj)
{
struct kobj_type *t = get_ktype(kobj);
const char *name = kobj->name;
pr_debug("kobject: '%s' (%p): %s\n",
kobject_name(kobj), kobj, __func__);
if (t && !t->release)
pr_debug("kobject: '%s' (%p): does not have a release() "
"function, it is broken and must be fixed.\n",
kobject_name(kobj), kobj);
/* send "remove" if the caller did not do it but sent "add" */
if (kobj->state_add_uevent_sent && !kobj->state_remove_uevent_sent) {
pr_debug("kobject: '%s' (%p): auto cleanup 'remove' event\n",
kobject_name(kobj), kobj);
kobject_uevent(kobj, KOBJ_REMOVE);
}
/* remove from sysfs if the caller did not do it */
if (kobj->state_in_sysfs) {
pr_debug("kobject: '%s' (%p): auto cleanup kobject_del\n",
kobject_name(kobj), kobj);
kobject_del(kobj);
}
if (t && t->release) {
pr_debug("kobject: '%s' (%p): calling ktype release\n",
kobject_name(kobj), kobj);
t->release(kobj);
}
/* free name if we allocated it */
if (name) {
pr_debug("kobject: '%s': free name\n", name);
kfree(name);
}
}
static void kobject_release(struct kref *kref)
{
kobject_cleanup(container_of(kref, struct kobject, kref));
}
/**
* kobject_put - decrement refcount for object.
* @kobj: object.
*
* Decrement the refcount, and if 0, call kobject_cleanup().
*/
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_get()和kobject_put()走的完全是引用計數的路線。kobject_put()會在引用計數降爲零時撤銷整個kobject的存在：向用戶空間發生REMOVE消息，從sysfs中刪除相應目錄，調用kobj_type中定義的release函數，釋放name所佔的空間。
看看前面介紹的API。
int kobject_set_name(struct kobject *kobj, const char *name, ...)
__attribute__((format(printf, 2, 3)));
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
va_list vargs);
void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
int __must_check kobject_add(struct kobject *kobj,
struct kobject *parent,
const char *fmt, ...);
int __must_check kobject_init_and_add(struct kobject *kobj,
struct kobj_type *ktype,
struct kobject *parent,
const char *fmt, ...);
void kobject_del(struct kobject *kobj);
int __must_check kobject_rename(struct kobject *, const char *new_name);
int __must_check kobject_move(struct kobject *, struct kobject *);
struct kobject *kobject_get(struct kobject *kobj);
void kobject_put(struct kobject *kobj);
char *kobject_get_path(struct kobject *kobj, gfp_t flag);基本上概擴了kobject從創建到刪除，包括中間改名字，改位置，以及引用計數的變動。
當然，kobject創建仍比較麻煩，因爲ktype需要自己寫。下面就是kobject提供的一種快速創建方法。
static ssize_t kobj_attr_show(struct kobject *kobj, struct attribute *attr,
char *buf)
{
struct kobj_attribute *kattr;
ssize_t ret = -EIO;
kattr = container_of(attr, struct kobj_attribute, attr);
if (kattr->show)
ret = kattr->show(kobj, kattr, buf);
return ret;
}
static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
const char *buf, size_t count)
{
struct kobj_attribute *kattr;
ssize_t ret = -EIO;
kattr = container_of(attr, struct kobj_attribute, attr);
if (kattr->store)
ret = kattr->store(kobj, kattr, buf, count);
return ret;
}
struct sysfs_ops kobj_sysfs_ops = {
.show = kobj_attr_show,
.store = kobj_attr_store,
};
static void dynamic_kobj_release(struct kobject *kobj)
{
pr_debug("kobject: (%p): %s\n", kobj, __func__);
kfree(kobj);
}
static struct kobj_type dynamic_kobj_ktype = {
.release = dynamic_kobj_release,
.sysfs_ops = &kobj_sysfs_ops,
};這個就是kobject自身提供的一種kobj_type，叫做dynamic_kobj_ktype。它沒有提供默認的屬性，但提供了release函數及訪問屬性的方法。
struct kobject *kobject_create(void)
{
struct kobject *kobj;
kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
if (!kobj)
return NULL;
kobject_init(kobj, &dynamic_kobj_ktype);
return kobj;
}
struct kobject *kobject_create_and_add(const char *name, struct kobject *parent)
{
struct kobject *kobj;
int retval;
kobj = kobject_create();
if (!kobj)
return NULL;
retval = kobject_add(kobj, parent, "%s", name);
if (retval) {
printk(KERN_WARNING "%s: kobject_add error: %d\n",
__func__, retval);
kobject_put(kobj);
kobj = NULL;
}
return kobj;
}在kobject_create()及kobject_create_add()中，使用了這種dynamic_kobj_ktype。這是一種很好的偷懶方法。因爲release()函數會釋放kobj，所以這裏的kobj必須是kobject_create()動態創建的。這裏的kobject_create()和kobject_init()相對，kobject_create_and_add()和kobject_init_and_add()相對。值得一提的是，這裏用kobject_create()和kobject_create_and_add()創建的kobject無法嵌入其它結構，是獨立的存在，所以用到的地方很少。
void kset_init(struct kset *k)
{
kobject_init_internal(&k->kobj);
INIT_LIST_HEAD(&k->list);
spin_lock_init(&k->list_lock);
}kset_init()對kset進行初始化。不過它的界限同kobject差不多。
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_register()最大的特點是簡單，它只負責把kset中的kobject連入系統，併發布KOBJ_ADD消息。所以在調用它之前，你要先設置好k->kobj.name、k->kobj.parent、k->kobj.kset。
void kset_unregister(struct kset *k)
{
if (!k)
return;
kobject_put(&k->kobj);
}kset_unregister()只是簡單地釋放創建時獲得的引用計數。使用引用計數就是這麼簡單。
struct kobject *kset_find_obj(struct kset *kset, const char *name)
{
struct kobject *k;
struct kobject *ret = NULL;
spin_lock(&kset->list_lock);
list_for_each_entry(k, &kset->list, entry) {
if (kobject_name(k) && !strcmp(kobject_name(k), name)) {
ret = kobject_get(k);
break;
}
}
spin_unlock(&kset->list_lock);
return ret;
}kset_find_obj()從kset的鏈表中找到名爲name的kobject。這純粹是一個對外的API。
static void kset_release(struct kobject *kobj)
{
struct kset *kset = container_of(kobj, struct kset, kobj);
pr_debug("kobject: '%s' (%p): %s\n",
kobject_name(kobj), kobj, __func__);
kfree(kset);
}
static struct kobj_type kset_ktype = {
.sysfs_ops = &kobj_sysfs_ops,
.release = kset_release,
};與kobject相對的，kset也提供了一種kobj_type，叫做kset_ktype。
static struct kset *kset_create(const char *name,
struct kset_uevent_ops *uevent_ops,
struct kobject *parent_kobj)
{
struct kset *kset;
int retval;
kset = kzalloc(sizeof(*kset), GFP_KERNEL);
if (!kset)
return NULL;
retval = kobject_set_name(&kset->kobj, name);
if (retval) {
kfree(kset);
return NULL;
}
kset->uevent_ops = uevent_ops;
kset->kobj.parent = parent_kobj;
/*
* The kobject of this kset will have a type of kset_ktype and belong to
* no kset itself. That way we can properly free it when it is
* finished being used.
*/
kset->kobj.ktype = &kset_ktype;
kset->kobj.kset = NULL;
return kset;
}
/**
* kset_create_and_add - create a struct kset dynamically and add it to sysfs
*
* @name: the name for the kset
* @uevent_ops: a struct kset_uevent_ops for the kset
* @parent_kobj: the parent kobject of this kset, if any.
*
* This function creates a kset structure dynamically and registers it
* with sysfs. When you are finished with this structure, call
* kset_unregister() and the structure will be dynamically freed when it
* is no longer being used.
*
* If the kset was not able to be created, NULL will be returned.
*/
struct kset *kset_create_and_add(const char *name,
struct kset_uevent_ops *uevent_ops,
struct kobject *parent_kobj)
{
struct kset *kset;
int error;
kset = kset_create(name, uevent_ops, parent_kobj);
if (!kset)
return NULL;
error = kset_register(kset);
if (error) {
kfree(kset);
return NULL;
}
return kset;
}
kset_create()和kset_create_and_add()就是使用kset_type的快速創建函數。
說實話，使用kobject_create_and_add()的比較少見，但使用 kset_create_and_add()的情形還是見過一些的。比如sysfs中那些頂層的目錄，就是單純的目錄，不需要嵌入什麼很複雜的結構，用簡單的kset_create_and_add()創建就好了。
static inline const char *kobject_name(const struct kobject *kobj)
{
return kobj->name;
}
static inline struct kset *to_kset(struct kobject *kobj)
{
return kobj ? container_of(kobj, struct kset, kobj) : NULL;
}
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);
}
static inline struct kobj_type *get_ktype(struct kobject *kobj)
{
return kobj->ktype;
}這些是在kobject.h中的內聯函數。這裏內聯函數更多的意思是方便，易於屏蔽內部實現。
以上就是kobject共800餘行的代碼實現，當然我們忽略了uevent的那部分。
事實證明，自底向上或者順序的代碼分析方法，還是很適合千行左右的代碼分析。而且這樣分析很全面，容易我們洞察整個模塊的意圖，從而在理解代碼時從較高的抽象角度去看。
