mmc: s3c6410: add new quirk in sdhci driver and update ADMA descriptor build

[safe/jmp/linux-2.6] / lib / kobject.c

diff --git a/lib/kobject.c b/lib/kobject.c
index ae6bb90..f07c572 100644 (file)
--- a/lib/kobject.c
+++ b/lib/kobject.c
@@ -212,12 +212,15 @@ static int kobject_add_internal(struct kobject *kobj)
  * @fmt: format string used to build the name
  * @vargs: vargs to format the string.
  */
-static int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
+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;
@@ -397,6 +400,7 @@ 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];
 
@@ -420,15 +424,27 @@ int kobject_rename(struct kobject *kobj, const char *new_name)
        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. */
-       if (!error)
-               kobject_uevent_env(kobj, KOBJ_MOVE, envp);
+       kobject_uevent_env(kobj, KOBJ_MOVE, envp);
 
 out:
+       kfree(dup_name);
        kfree(devpath_string);
        kfree(devpath);
        kobject_put(kobj);
@@ -684,7 +700,7 @@ static ssize_t kobj_attr_store(struct kobject *kobj, struct attribute *attr,
        return ret;
 }
 
-struct sysfs_ops kobj_sysfs_ops = {
+const struct sysfs_ops kobj_sysfs_ops = {
        .show   = kobj_attr_show,
        .store  = kobj_attr_store,
 };
@@ -773,15 +789,20 @@ static struct kobj_type kset_ktype = {
  * If the kset was not able to be created, NULL will be returned.
  */
 static struct kset *kset_create(const char *name,
-                               struct kset_uevent_ops *uevent_ops,
+                               const 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;
-       kobject_set_name(&kset->kobj, name);
+       retval = kobject_set_name(&kset->kobj, name);
+       if (retval) {
+               kfree(kset);
+               return NULL;
+       }
        kset->uevent_ops = uevent_ops;
        kset->kobj.parent = parent_kobj;
 
@@ -811,7 +832,7 @@ static struct kset *kset_create(const char *name,
  * 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,
+                                const struct kset_uevent_ops *uevent_ops,
                                 struct kobject *parent_kobj)
 {
        struct kset *kset;
@@ -829,6 +850,121 @@ struct kset *kset_create_and_add(const char *name,
 }
 EXPORT_SYMBOL_GPL(kset_create_and_add);
 
+
+static DEFINE_SPINLOCK(kobj_ns_type_lock);
+static const struct kobj_ns_type_operations *kobj_ns_ops_tbl[KOBJ_NS_TYPES];
+
+int kobj_ns_type_register(const struct kobj_ns_type_operations *ops)
+{
+       enum kobj_ns_type type = ops->type;
+       int error;
+
+       spin_lock(&kobj_ns_type_lock);
+
+       error = -EINVAL;
+       if (type >= KOBJ_NS_TYPES)
+               goto out;
+
+       error = -EINVAL;
+       if (type <= KOBJ_NS_TYPE_NONE)
+               goto out;
+
+       error = -EBUSY;
+       if (kobj_ns_ops_tbl[type])
+               goto out;
+
+       error = 0;
+       kobj_ns_ops_tbl[type] = ops;
+
+out:
+       spin_unlock(&kobj_ns_type_lock);
+       return error;
+}
+
+int kobj_ns_type_registered(enum kobj_ns_type type)
+{
+       int registered = 0;
+
+       spin_lock(&kobj_ns_type_lock);
+       if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES))
+               registered = kobj_ns_ops_tbl[type] != NULL;
+       spin_unlock(&kobj_ns_type_lock);
+
+       return registered;
+}
+
+const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent)
+{
+       const struct kobj_ns_type_operations *ops = NULL;
+
+       if (parent && parent->ktype->child_ns_type)
+               ops = parent->ktype->child_ns_type(parent);
+
+       return ops;
+}
+
+const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj)
+{
+       return kobj_child_ns_ops(kobj->parent);
+}
+
+
+const void *kobj_ns_current(enum kobj_ns_type type)
+{
+       const void *ns = NULL;
+
+       spin_lock(&kobj_ns_type_lock);
+       if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
+           kobj_ns_ops_tbl[type])
+               ns = kobj_ns_ops_tbl[type]->current_ns();
+       spin_unlock(&kobj_ns_type_lock);
+
+       return ns;
+}
+
+const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk)
+{
+       const void *ns = NULL;
+
+       spin_lock(&kobj_ns_type_lock);
+       if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
+           kobj_ns_ops_tbl[type])
+               ns = kobj_ns_ops_tbl[type]->netlink_ns(sk);
+       spin_unlock(&kobj_ns_type_lock);
+
+       return ns;
+}
+
+const void *kobj_ns_initial(enum kobj_ns_type type)
+{
+       const void *ns = NULL;
+
+       spin_lock(&kobj_ns_type_lock);
+       if ((type > KOBJ_NS_TYPE_NONE) && (type < KOBJ_NS_TYPES) &&
+           kobj_ns_ops_tbl[type])
+               ns = kobj_ns_ops_tbl[type]->initial_ns();
+       spin_unlock(&kobj_ns_type_lock);
+
+       return ns;
+}
+
+/*
+ * kobj_ns_exit - invalidate a namespace tag
+ *
+ * @type: the namespace type (i.e. KOBJ_NS_TYPE_NET)
+ * @ns: the actual namespace being invalidated
+ *
+ * This is called when a tag is no longer valid.  For instance,
+ * when a network namespace exits, it uses this helper to
+ * make sure no sb's sysfs_info points to the now-invalidated
+ * netns.
+ */
+void kobj_ns_exit(enum kobj_ns_type type, const void *ns)
+{
+       sysfs_exit_ns(type, ns);
+}
+
+
 EXPORT_SYMBOL(kobject_get);
 EXPORT_SYMBOL(kobject_put);
 EXPORT_SYMBOL(kobject_del);