kobject: documentation: Fix erroneous function example in kobject doc.

(such as assuming that the kobject is at the beginning of the structure)

and, instead, use the container_of() macro, found in ``<linux/kernel.h>``::

    container_of(pointer, type, member)

    container_of(ptr, type, member)

where:

  * ``pointer`` is the pointer to the embedded kobject,

  * ``ptr`` is the pointer to the embedded kobject,

  * ``type`` is the type of the containing structure, and

  * ``member`` is the name of the structure field to which ``pointer`` points.

    int kobject_rename(struct kobject *kobj, const char *new_name);

kobject_rename does not perform any locking or have a solid notion of

kobject_rename() does not perform any locking or have a solid notion of

what names are valid so the caller must provide their own sanity checking

and serialization.

exception where a single kobject should be created.  To create such an

entry, use the function::

    struct kobject *kobject_create_and_add(char *name, struct kobject *parent);

    struct kobject *kobject_create_and_add(const char *name, struct kobject *parent);

This function will create a kobject and place it in sysfs in the location

underneath the specified parent kobject.  To create simple attributes

associated with this kobject, use::

    int sysfs_create_file(struct kobject *kobj, struct attribute *attr);

    int sysfs_create_file(struct kobject *kobj, const struct attribute *attr);

or::

    int sysfs_create_group(struct kobject *kobj, struct attribute_group *grp);

    int sysfs_create_group(struct kobject *kobj, const struct attribute_group *grp);

Both types of attributes used here, with a kobject that has been created

with the kobject_create_and_add(), can be of type kobj_attribute, so no

            void (*release)(struct kobject *kobj);

            const struct sysfs_ops *sysfs_ops;

            struct attribute **default_attrs;

            const struct attribute_group **default_groups;

            const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);

            const void *(*namespace)(struct kobject *kobj);

            void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);

    };

This structure is used to describe a particular type of kobject (or, more

kset use::

  struct kset *kset_create_and_add(const char *name,

                                   struct kset_uevent_ops *u,

                                   struct kobject *parent);

                                   const struct kset_uevent_ops *uevent_ops,

                                   struct kobject *parent_kobj);

When you are finished with the kset, call::

  void kset_unregister(struct kset *kset);

  void kset_unregister(struct kset *k);

to destroy it.  This removes the kset from sysfs and decrements its reference

count.  When the reference count goes to zero, the kset will be released.

associated with it, it can use the struct kset_uevent_ops to handle it::

  struct kset_uevent_ops {

          int (*filter)(struct kset *kset, struct kobject *kobj);

          const char *(*name)(struct kset *kset, struct kobject *kobj);

          int (*uevent)(struct kset *kset, struct kobject *kobj,

          int (* const filter)(struct kset *kset, struct kobject *kobj);

          const char *(* const name)(struct kset *kset, struct kobject *kobj);

          int (* const uevent)(struct kset *kset, struct kobject *kobj,

                        struct kobj_uevent_env *env);

  };