linux_kobject.c

/*-
 * Copyright (c) 2010 Isilon Systems, Inc.
 * Copyright (c) 2010 iX Systems, Inc.
 * Copyright (c) 2010 Panasas, Inc.
 * Copyright (c) 2013-2021 Mellanox Technologies, Ltd.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice unmodified, this list of conditions, and the following
 *    disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/kobject.h>
#include <linux/sysfs.h>

static void kset_join(struct kobject *kobj);
static void kset_leave(struct kobject *kobj);
static void kset_kfree(struct kobject *kobj);

struct kobject *
kobject_create(void)
{
	struct kobject *kobj;

	kobj = kzalloc(sizeof(*kobj), GFP_KERNEL);
	if (kobj == NULL)
		return (NULL);
	kobject_init(kobj, &linux_kfree_type);

	return (kobj);
}


int
kobject_set_name_vargs(struct kobject *kobj, const char *fmt, va_list args)
{
	va_list tmp_va;
	int len;
	char *old;
	char *name;
	char dummy;

	old = kobj->name;

	if (old && fmt == NULL)
		return (0);

	/* compute length of string */
	va_copy(tmp_va, args);
	len = vsnprintf(&dummy, 0, fmt, tmp_va);
	va_end(tmp_va);

	/* account for zero termination */
	len++;

	/* check for error */
	if (len < 1)
		return (-EINVAL);

	/* allocate memory for string */
	name = kzalloc(len, GFP_KERNEL);
	if (name == NULL)
		return (-ENOMEM);
	vsnprintf(name, len, fmt, args);
	kobj->name = name;

	/* free old string */
	kfree(old);

	/* filter new string */
	for (; *name != '\0'; name++)
		if (*name == '/')
			*name = '!';
	return (0);
}

int
kobject_set_name(struct kobject *kobj, const char *fmt, ...)
{
	va_list args;
	int error;

	va_start(args, fmt);
	error = kobject_set_name_vargs(kobj, fmt, args);
	va_end(args);

	return (error);
}

static int
kobject_add_complete(struct kobject *kobj)
{
	const struct kobj_type *t;
	int error;

	if (kobj->kset != NULL) {
		kset_join(kobj);
		kobj->parent = &kobj->kset->kobj;
	}

	error = sysfs_create_dir(kobj);
	if (error == 0 && kobj->ktype && kobj->ktype->default_attrs) {
		struct attribute **attr;
		t = kobj->ktype;

		for (attr = t->default_attrs; *attr != NULL; attr++) {
			error = sysfs_create_file(kobj, *attr);
			if (error != 0)
				break;
		}
		if (error != 0)
			sysfs_remove_dir(kobj);
	}

	if (error != 0)
		kset_leave(kobj);

	return (error);
}

int
kobject_add(struct kobject *kobj, struct kobject *parent, const char *fmt, ...)
{
	va_list args;
	int error;

	kobj->parent = parent;

	va_start(args, fmt);
	error = kobject_set_name_vargs(kobj, fmt, args);
	va_end(args);
	if (error)
		return (error);

	return kobject_add_complete(kobj);
}

int
kobject_init_and_add(struct kobject *kobj, const struct kobj_type *ktype,
    struct kobject *parent, const char *fmt, ...)
{
	va_list args;
	int error;

	kobject_init(kobj, ktype);
	kobj->ktype = ktype;
	kobj->parent = parent;
	kobj->name = NULL;

	va_start(args, fmt);
	error = kobject_set_name_vargs(kobj, fmt, args);
	va_end(args);
	if (error)
		return (error);
	return kobject_add_complete(kobj);
}

void
linux_kobject_release(struct kref *kref)
{
	struct kobject *kobj;
	char *name;

	kobj = container_of(kref, struct kobject, kref);
	sysfs_remove_dir(kobj);
	kset_leave(kobj);
	name = kobj->name;
	if (kobj->ktype && kobj->ktype->release)
		kobj->ktype->release(kobj);
	kfree(name);
}

static void
linux_kobject_kfree(struct kobject *kobj)
{
	kfree(kobj);
}

const struct kobj_type linux_kfree_type = {
	.release = linux_kobject_kfree
};

void
linux_kobject_kfree_name(struct kobject *kobj)
{
	if (kobj) {
		kfree(kobj->name);
	}
}

static ssize_t
lkpi_kobj_attr_show(struct kobject *kobj, struct attribute *attr, char *buf)
{
	struct kobj_attribute *ka =
	    container_of(attr, struct kobj_attribute, attr);

	if (ka->show == NULL)
		return (-EIO);

	return (ka->show(kobj, ka, buf));
}

static ssize_t
lkpi_kobj_attr_store(struct kobject *kobj, struct attribute *attr,
    const char *buf, size_t count)
{
	struct kobj_attribute *ka =
	    container_of(attr, struct kobj_attribute, attr);

	if (ka->store == NULL)
		return (-EIO);

	return (ka->store(kobj, ka, buf, count));
}

const struct sysfs_ops kobj_sysfs_ops = {
	.show	= lkpi_kobj_attr_show,
	.store	= lkpi_kobj_attr_store,
};

const struct kobj_type linux_kset_kfree_type = {
	.release = kset_kfree
};

static struct kset *
kset_create(const char *name,
    const struct kset_uevent_ops *uevent_ops,
    struct kobject *parent_kobj)
{
	struct kset *kset;

	kset = kzalloc(sizeof(*kset), GFP_KERNEL);
	if (kset == NULL)
		return (NULL);

	kset->uevent_ops = uevent_ops;

	kobject_set_name(&kset->kobj, "%s", name);
	kset->kobj.parent = parent_kobj;
	kset->kobj.kset = NULL;

	return (kset);
}

void
kset_init(struct kset *kset)
{
	kobject_init(&kset->kobj, &linux_kset_kfree_type);
	INIT_LIST_HEAD(&kset->list);
	spin_lock_init(&kset->list_lock);
}

static void
kset_join(struct kobject *kobj)
{
	struct kset *kset;

	kset = kobj->kset;
	if (kset == NULL)
		return;

	kset_get(kobj->kset);

	spin_lock(&kset->list_lock);
	list_add_tail(&kobj->entry, &kset->list);
	spin_unlock(&kset->list_lock);
}

static void
kset_leave(struct kobject *kobj)
{
	struct kset *kset;

	kset = kobj->kset;
	if (kset == NULL)
		return;

	spin_lock(&kset->list_lock);
	list_del_init(&kobj->entry);
	spin_unlock(&kset->list_lock);

	kset_put(kobj->kset);
}

struct kset *
kset_create_and_add(const char *name, const struct kset_uevent_ops *u,
    struct kobject *parent_kobj)
{
	int ret;
	struct kset *kset;

	kset = kset_create(name, u, parent_kobj);
	if (kset == NULL)
		return (NULL);

	ret = kset_register(kset);
	if (ret != 0) {
		linux_kobject_kfree_name(&kset->kobj);
		kfree(kset);
		return (NULL);
	}

	return (kset);
}

int
kset_register(struct kset *kset)
{
	int ret;

	if (kset == NULL)
		return -EINVAL;

	kset_init(kset);
	ret = kobject_add_complete(&kset->kobj);

	return ret;
}

void
kset_unregister(struct kset *kset)
{
	if (kset == NULL)
		return;

	kobject_del(&kset->kobj);
	kobject_put(&kset->kobj);
}

static void
kset_kfree(struct kobject *kobj)
{
	struct kset *kset;

	kset = to_kset(kobj);
	kfree(kset);
}