// SPDX-License-Identifier: GPL-2.0-only
/*
 * File attributes for Mediated devices
 *
 * Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
 *     Author: Neo Jia <cjia@nvidia.com>
 *             Kirti Wankhede <kwankhede@nvidia.com>
 */

#include <linux/sysfs.h>
#include <linux/ctype.h>
#include <linux/device.h>
#include <linux/slab.h>
#include <linux/uuid.h>
#include <linux/mdev.h>

#include "mdev_private.h"

/* Static functions */

static ssize_t mdev_type_attr_show(struct kobject *kobj,
                                     struct attribute *__attr, char *buf)
{
        struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
        struct mdev_type *type = to_mdev_type(kobj);
        ssize_t ret = -EIO;

        if (attr->show)
                ret = attr->show(kobj, type->parent->dev, buf);
        return ret;
}

static ssize_t mdev_type_attr_store(struct kobject *kobj,
                                      struct attribute *__attr,
                                      const char *buf, size_t count)
{
        struct mdev_type_attribute *attr = to_mdev_type_attr(__attr);
        struct mdev_type *type = to_mdev_type(kobj);
        ssize_t ret = -EIO;

        if (attr->store)
                ret = attr->store(&type->kobj, type->parent->dev, buf, count);
        return ret;
}

static const struct sysfs_ops mdev_type_sysfs_ops = {
        .show = mdev_type_attr_show,
        .store = mdev_type_attr_store,
};

static ssize_t create_store(struct kobject *kobj, struct device *dev,
                            const char *buf, size_t count)
{
        char *str;
        guid_t uuid;
        int ret;

        if ((count < UUID_STRING_LEN) || (count > UUID_STRING_LEN + 1))
                return -EINVAL;

        str = kstrndup(buf, count, GFP_KERNEL);
        if (!str)
                return -ENOMEM;

        ret = guid_parse(str, &uuid);
        kfree(str);
        if (ret)
                return ret;

        ret = mdev_device_create(kobj, dev, &uuid);
        if (ret)
                return ret;

        return count;
}

MDEV_TYPE_ATTR_WO(create);

static void mdev_type_release(struct kobject *kobj)
{
        struct mdev_type *type = to_mdev_type(kobj);

        pr_debug("Releasing group %s\n", kobj->name);
        kfree(type);
}

static struct kobj_type mdev_type_ktype = {
        .sysfs_ops = &mdev_type_sysfs_ops,
        .release = mdev_type_release,
};

static struct mdev_type *add_mdev_supported_type(struct mdev_parent *parent,
                                                 struct attribute_group *group)
{
        struct mdev_type *type;
        int ret;

        if (!group->name) {
                pr_err("%s: Type name empty!\n", __func__);
                return ERR_PTR(-EINVAL);
        }

        type = kzalloc(sizeof(*type), GFP_KERNEL);
        if (!type)
                return ERR_PTR(-ENOMEM);

        type->kobj.kset = parent->mdev_types_kset;

        ret = kobject_init_and_add(&type->kobj, &mdev_type_ktype, NULL,
                                   "%s-%s", dev_driver_string(parent->dev),
                                   group->name);
        if (ret) {
                kfree(type);
                return ERR_PTR(ret);
        }

        ret = sysfs_create_file(&type->kobj, &mdev_type_attr_create.attr);
        if (ret)
                goto attr_create_failed;

        type->devices_kobj = kobject_create_and_add("devices", &type->kobj);
        if (!type->devices_kobj) {
                ret = -ENOMEM;
                goto attr_devices_failed;
        }

        ret = sysfs_create_files(&type->kobj,
                                 (const struct attribute **)group->attrs);
        if (ret) {
                ret = -ENOMEM;
                goto attrs_failed;
        }

        type->group = group;
        type->parent = parent;
        return type;

attrs_failed:
        kobject_put(type->devices_kobj);
attr_devices_failed:
        sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
attr_create_failed:
        kobject_del(&type->kobj);
        kobject_put(&type->kobj);
        return ERR_PTR(ret);
}

static void remove_mdev_supported_type(struct mdev_type *type)
{
        sysfs_remove_files(&type->kobj,
                           (const struct attribute **)type->group->attrs);
        kobject_put(type->devices_kobj);
        sysfs_remove_file(&type->kobj, &mdev_type_attr_create.attr);
        kobject_del(&type->kobj);
        kobject_put(&type->kobj);
}

static int add_mdev_supported_type_groups(struct mdev_parent *parent)
{
        int i;

        for (i = 0; parent->ops->supported_type_groups[i]; i++) {
                struct mdev_type *type;

                type = add_mdev_supported_type(parent,
                                        parent->ops->supported_type_groups[i]);
                if (IS_ERR(type)) {
                        struct mdev_type *ltype, *tmp;

                        list_for_each_entry_safe(ltype, tmp, &parent->type_list,
                                                  next) {
                                list_del(&ltype->next);
                                remove_mdev_supported_type(ltype);
                        }
                        return PTR_ERR(type);
                }
                list_add(&type->next, &parent->type_list);
        }
        return 0;
}

/* mdev sysfs functions */
void parent_remove_sysfs_files(struct mdev_parent *parent)
{
        struct mdev_type *type, *tmp;

        list_for_each_entry_safe(type, tmp, &parent->type_list, next) {
                list_del(&type->next);
                remove_mdev_supported_type(type);
        }

        sysfs_remove_groups(&parent->dev->kobj, parent->ops->dev_attr_groups);
        kset_unregister(parent->mdev_types_kset);
}

int parent_create_sysfs_files(struct mdev_parent *parent)
{
        int ret;

        parent->mdev_types_kset = kset_create_and_add("mdev_supported_types",
                                               NULL, &parent->dev->kobj);

        if (!parent->mdev_types_kset)
                return -ENOMEM;

        INIT_LIST_HEAD(&parent->type_list);

        ret = sysfs_create_groups(&parent->dev->kobj,
                                  parent->ops->dev_attr_groups);
        if (ret)
                goto create_err;

        ret = add_mdev_supported_type_groups(parent);
        if (ret)
                sysfs_remove_groups(&parent->dev->kobj,
                                    parent->ops->dev_attr_groups);
        else
                return ret;

create_err:
        kset_unregister(parent->mdev_types_kset);
        return ret;
}

static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
                            const char *buf, size_t count)
{
        unsigned long val;

        if (kstrtoul(buf, 0, &val) < 0)
                return -EINVAL;

        if (val && device_remove_file_self(dev, attr)) {
                int ret;

                ret = mdev_device_remove(dev);
                if (ret)
                        return ret;
        }

        return count;
}

static DEVICE_ATTR_WO(remove);

static const struct attribute *mdev_device_attrs[] = {
        &dev_attr_remove.attr,
        NULL,
};

int  mdev_create_sysfs_files(struct device *dev, struct mdev_type *type)
{
        int ret;

        ret = sysfs_create_link(type->devices_kobj, &dev->kobj, dev_name(dev));
        if (ret)
                return ret;

        ret = sysfs_create_link(&dev->kobj, &type->kobj, "mdev_type");
        if (ret)
                goto type_link_failed;

        ret = sysfs_create_files(&dev->kobj, mdev_device_attrs);
        if (ret)
                goto create_files_failed;

        return ret;

create_files_failed:
        sysfs_remove_link(&dev->kobj, "mdev_type");
type_link_failed:
        sysfs_remove_link(type->devices_kobj, dev_name(dev));
        return ret;
}

void mdev_remove_sysfs_files(struct device *dev, struct mdev_type *type)
{
        sysfs_remove_files(&dev->kobj, mdev_device_attrs);
        sysfs_remove_link(&dev->kobj, "mdev_type");
        sysfs_remove_link(type->devices_kobj, dev_name(dev));
}