drivers/base/init.c
/**

 * driver_init - initialize driver model.

 *

 * Call the driver model init functions to initialize their

 * subsystems. Called early from init/main.c.

 */

void __init driver_init(void)

{

        /* These are the core pieces */

        devices_init(); //  /sys/devices

        buses_init(); // /sys/bus

        classes_init(); // /sys/class

        firmware_init();

        hypervisor_init();

        /* These are also core pieces, but must come after the

         * core core pieces.

         */

        platform_bus_init();

        system_bus_init();

        cpu_dev_init();

        memory_dev_init();

}

drivers/base/platform.c

struct device platform_bus = {

        .bus_id         = "platform",

};

struct bus_type platform_bus_type = {

        .name           = "platform",

        .dev_attrs      = platform_dev_attrs,

        .match          = platform_match,

        .uevent         = platform_uevent,

        .pm             = PLATFORM_PM_OPS_PTR,

};

int __init platform_bus_init(void)

{

        int error;

　　　　 /* /sys/devices/platform (this platform is bus_id's value) */

 　　　　error = device_register(&platform_bus);
　　　　 if (error) 
 　　　　　　　　return error; 

　　　　  /* /sys/bus/platform (this platform is the value of bus_type's name field) */

　　　　  error = bus_register(&platform_bus_type); 

　　　　　if (error) 
 　　　　 　　　　device_unregister(&platform_bus); 

　　　　　return error; 
}

/**

 * struct bus_type_private - structure to hold the private to the driver core portions of the bus_type structure.

 *

 * @subsys - the struct kset that defines this bus.  This is the main kobject

 * @drivers_kset - the list of drivers associated with this bus

 * @devices_kset - the list of devices associated with this bus

 * @klist_devices - the klist to iterate over the @devices_kset

 * @klist_drivers - the klist to iterate over the @drivers_kset

 * @bus_notifier - the bus notifier list for anything that cares about things

 * on this bus.

 * @bus - pointer back to the struct bus_type that this structure is associated

 * with.

 *

 * This structure is the one that is the actual kobject allowing struct

 * bus_type to be statically allocated safely.  Nothing outside of the driver

 * core should ever touch these fields.

 */

struct bus_type_private {

        struct kset subsys;

        struct kset *drivers_kset;

        struct kset *devices_kset;

        struct klist klist_devices;

        struct klist klist_drivers;

        struct blocking_notifier_head bus_notifier;

        unsigned int drivers_autoprobe:;

        struct bus_type *bus;

};

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);                       

        retval = kobject_set_name(&priv->subsys.kobj, "%s", bus->name);

        if (retval)

                goto out;                                                       

        priv->subsys.kobj.kset = bus_kset;

        priv->subsys.kobj.ktype = &bus_ktype;

        priv->drivers_autoprobe = ;                                            

        retval = kset_register(&priv->subsys);

        if (retval)

                goto out;                                                       

        retval = bus_create_file(bus, &bus_attr_uevent);

        if (retval)

                goto bus_uevent_fail;                                           

        priv->devices_kset = kset_create_and_add("devices", NULL,

                                                 &priv->subsys.kobj);

        if (!priv->devices_kset) {

                retval = -ENOMEM;

                goto bus_devices_fail;

        }                                                                       

        priv->drivers_kset = kset_create_and_add("drivers", NULL,

                                                 &priv->subsys.kobj);

        if (!priv->drivers_kset) {

                retval = -ENOMEM;

                goto bus_drivers_fail;

        }                                                                       

        klist_init(&priv->klist_devices, klist_devices_get, klist_devices_put);

        klist_init(&priv->klist_drivers, NULL, NULL);                           

        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 ;

/**

 * kset_register - initialize and add a kset.

 * @k: kset.

 */

int kset_register(struct kset *k)

{

        int err;                                                                   

        if (!k)

                return -EINVAL;                                                    

        kset_init(k); // INIT_LIST_HEAD(&k->kobj->entry); INIT_LIST_HEAD(&k->list);

        err = kobject_add_internal(&k->kobj);

        if (err)

                return err;

        kobject_uevent(&k->kobj, KOBJ_ADD);

        return ;

} 

static int kobject_add_internal(struct kobject *kobj)

{

    kobj_kset_join(kobj);

    error = create_dir(kobj); // /sys/bus/platform

}

/* add the kobject to its kset's list */

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);

} 

If a kset is associated with a kobject, then the parent for the kobject can be set to
NULL in the call to kobject_add() and then the kobject's parent will be the kset itself.

确切的说是kobject's parent赋值为kobject关联的kset's kobjcect

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:;

        unsigned int state_in_sysfs:;

        unsigned int state_add_uevent_sent:;

        unsigned int state_remove_uevent_sent:;

}; 

 *

 * 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.

 *

 * @list: the list of all kobjects for this kset

 * @list_lock: a lock for iterating over the kobjects

 * @kobj: the embedded kobject for this kset (recursion, isn't it fun...)

 * @uevent_ops: the set of uevent operations for this kset.  These are

 * called whenever a kobject has something happen to it so that the kset

 * can add new environment variables, or filter out the uevents if so

 * desired.

 */

struct kset {

        struct list_head list;

        spinlock_t list_lock;

        struct kobject kobj;

        struct kset_uevent_ops *uevent_ops;

};

struct list_head {

        struct list_head *next, *prev;

};