// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * Module sysfs support
 *
 * Copyright (C) 2008 Rusty Russell
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/fs.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include <linux/kallsyms.h>
#include <linux/mutex.h>
#include "internal.h"

/*
 * /sys/module/foo/sections stuff
 * J. Corbet <corbet@lwn.net>
 */
#ifdef CONFIG_KALLSYMS
struct module_sect_attrs {
        struct attribute_group grp;
        struct bin_attribute attrs[];
};

#define MODULE_SECT_READ_SIZE (3 /* "0x", "\n" */ + (BITS_PER_LONG / 4))
static ssize_t module_sect_read(struct file *file, struct kobject *kobj,
                                const struct bin_attribute *battr,
                                char *buf, loff_t pos, size_t count)
{
        char bounce[MODULE_SECT_READ_SIZE + 1];
        size_t wrote;

        if (pos != 0)
                return -EINVAL;

        /*
         * Since we're a binary read handler, we must account for the
         * trailing NUL byte that sprintf will write: if "buf" is
         * too small to hold the NUL, or the NUL is exactly the last
         * byte, the read will look like it got truncated by one byte.
         * Since there is no way to ask sprintf nicely to not write
         * the NUL, we have to use a bounce buffer.
         */
        wrote = scnprintf(bounce, sizeof(bounce), "0x%px\n",
                          kallsyms_show_value(file->f_cred)
                                ? battr->private : NULL);
        count = min(count, wrote);
        memcpy(buf, bounce, count);

        return count;
}

static void free_sect_attrs(struct module_sect_attrs *sect_attrs)
{
        const struct bin_attribute *const *bin_attr;

        for (bin_attr = sect_attrs->grp.bin_attrs; *bin_attr; bin_attr++)
                kfree((*bin_attr)->attr.name);
        kfree(sect_attrs->grp.bin_attrs);
        kfree(sect_attrs);
}

static int add_sect_attrs(struct module *mod, const struct load_info *info)
{
        struct module_sect_attrs *sect_attrs;
        const struct bin_attribute **gattr;
        struct bin_attribute *sattr;
        unsigned int nloaded = 0, i;
        int ret;

        /* Count loaded sections and allocate structures */
        for (i = 0; i < info->hdr->e_shnum; i++)
                if (!sect_empty(&info->sechdrs[i]))
                        nloaded++;
        sect_attrs = kzalloc_flex(*sect_attrs, attrs, nloaded);
        if (!sect_attrs)
                return -ENOMEM;

        gattr = kzalloc_objs(*gattr, nloaded + 1);
        if (!gattr) {
                kfree(sect_attrs);
                return -ENOMEM;
        }

        /* Setup section attributes. */
        sect_attrs->grp.name = "sections";
        sect_attrs->grp.bin_attrs = gattr;

        sattr = &sect_attrs->attrs[0];
        for (i = 0; i < info->hdr->e_shnum; i++) {
                Elf_Shdr *sec = &info->sechdrs[i];

                if (sect_empty(sec))
                        continue;
                sysfs_bin_attr_init(sattr);
                sattr->attr.name =
                        kstrdup(info->secstrings + sec->sh_name, GFP_KERNEL);
                if (!sattr->attr.name) {
                        ret = -ENOMEM;
                        goto out;
                }
                sattr->read = module_sect_read;
                sattr->private = (void *)sec->sh_addr;
                sattr->size = MODULE_SECT_READ_SIZE;
                sattr->attr.mode = 0400;
                *(gattr++) = sattr++;
        }

        ret = sysfs_create_group(&mod->mkobj.kobj, &sect_attrs->grp);
        if (ret)
                goto out;

        mod->sect_attrs = sect_attrs;
        return 0;
out:
        free_sect_attrs(sect_attrs);
        return ret;
}

static void remove_sect_attrs(struct module *mod)
{
        if (mod->sect_attrs) {
                sysfs_remove_group(&mod->mkobj.kobj,
                                   &mod->sect_attrs->grp);
                /*
                 * We are positive that no one is using any sect attrs
                 * at this point.  Deallocate immediately.
                 */
                free_sect_attrs(mod->sect_attrs);
                mod->sect_attrs = NULL;
        }
}

/*
 * /sys/module/foo/notes/.section.name gives contents of SHT_NOTE sections.
 */

struct module_notes_attrs {
        struct attribute_group grp;
        struct bin_attribute attrs[];
};

static void free_notes_attrs(struct module_notes_attrs *notes_attrs)
{
        kfree(notes_attrs->grp.bin_attrs);
        kfree(notes_attrs);
}

static int add_notes_attrs(struct module *mod, const struct load_info *info)
{
        unsigned int notes, loaded, i;
        struct module_notes_attrs *notes_attrs;
        const struct bin_attribute **gattr;
        struct bin_attribute *nattr;
        int ret;

        /* Count notes sections and allocate structures.  */
        notes = 0;
        for (i = 0; i < info->hdr->e_shnum; i++)
                if (!sect_empty(&info->sechdrs[i]) &&
                    info->sechdrs[i].sh_type == SHT_NOTE)
                        ++notes;

        if (notes == 0)
                return 0;

        notes_attrs = kzalloc_flex(*notes_attrs, attrs, notes);
        if (!notes_attrs)
                return -ENOMEM;

        gattr = kzalloc_objs(*gattr, notes + 1);
        if (!gattr) {
                kfree(notes_attrs);
                return -ENOMEM;
        }

        notes_attrs->grp.name = "notes";
        notes_attrs->grp.bin_attrs = gattr;

        nattr = &notes_attrs->attrs[0];
        for (loaded = i = 0; i < info->hdr->e_shnum; ++i) {
                if (sect_empty(&info->sechdrs[i]))
                        continue;
                if (info->sechdrs[i].sh_type == SHT_NOTE) {
                        sysfs_bin_attr_init(nattr);
                        nattr->attr.name = mod->sect_attrs->attrs[loaded].attr.name;
                        nattr->attr.mode = 0444;
                        nattr->size = info->sechdrs[i].sh_size;
                        nattr->private = (void *)info->sechdrs[i].sh_addr;
                        nattr->read = sysfs_bin_attr_simple_read;
                        *(gattr++) = nattr++;
                }
                ++loaded;
        }

        ret = sysfs_create_group(&mod->mkobj.kobj, &notes_attrs->grp);
        if (ret)
                goto out;

        mod->notes_attrs = notes_attrs;
        return 0;

out:
        free_notes_attrs(notes_attrs);
        return ret;
}

static void remove_notes_attrs(struct module *mod)
{
        if (mod->notes_attrs) {
                sysfs_remove_group(&mod->mkobj.kobj,
                                   &mod->notes_attrs->grp);
                /*
                 * We are positive that no one is using any notes attrs
                 * at this point.  Deallocate immediately.
                 */
                free_notes_attrs(mod->notes_attrs);
                mod->notes_attrs = NULL;
        }
}

#else /* !CONFIG_KALLSYMS */
static inline int add_sect_attrs(struct module *mod, const struct load_info *info)
{
        return 0;
}
static inline void remove_sect_attrs(struct module *mod) { }
static inline int add_notes_attrs(struct module *mod, const struct load_info *info)
{
        return 0;
}
static inline void remove_notes_attrs(struct module *mod) { }
#endif /* CONFIG_KALLSYMS */

static void del_usage_links(struct module *mod)
{
#ifdef CONFIG_MODULE_UNLOAD
        struct module_use *use;

        mutex_lock(&module_mutex);
        list_for_each_entry(use, &mod->target_list, target_list)
                sysfs_remove_link(use->target->holders_dir, mod->name);
        mutex_unlock(&module_mutex);
#endif
}

static int add_usage_links(struct module *mod)
{
        int ret = 0;
#ifdef CONFIG_MODULE_UNLOAD
        struct module_use *use;

        mutex_lock(&module_mutex);
        list_for_each_entry(use, &mod->target_list, target_list) {
                ret = sysfs_create_link(use->target->holders_dir,
                                        &mod->mkobj.kobj, mod->name);
                if (ret)
                        break;
        }
        mutex_unlock(&module_mutex);
        if (ret)
                del_usage_links(mod);
#endif
        return ret;
}

static void module_remove_modinfo_attrs(struct module *mod, int end)
{
        const struct module_attribute *attr;
        int i;

        for (i = 0; (attr = &mod->modinfo_attrs[i]); i++) {
                if (end >= 0 && i > end)
                        break;
                /* pick a field to test for end of list */
                if (!attr->attr.name)
                        break;
                sysfs_remove_file(&mod->mkobj.kobj, &attr->attr);
                if (attr->free)
                        attr->free(mod);
        }
        kfree(mod->modinfo_attrs);
}

static int module_add_modinfo_attrs(struct module *mod)
{
        const struct module_attribute *attr;
        struct module_attribute *temp_attr;
        int error = 0;
        int i;

        mod->modinfo_attrs = kzalloc((sizeof(struct module_attribute) *
                                        (modinfo_attrs_count + 1)),
                                        GFP_KERNEL);
        if (!mod->modinfo_attrs)
                return -ENOMEM;

        temp_attr = mod->modinfo_attrs;
        for (i = 0; (attr = modinfo_attrs[i]); i++) {
                if (!attr->test || attr->test(mod)) {
                        memcpy(temp_attr, attr, sizeof(*temp_attr));
                        sysfs_attr_init(&temp_attr->attr);
                        error = sysfs_create_file(&mod->mkobj.kobj,
                                                  &temp_attr->attr);
                        if (error)
                                goto error_out;
                        ++temp_attr;
                }
        }

        return 0;

error_out:
        if (i > 0)
                module_remove_modinfo_attrs(mod, --i);
        else
                kfree(mod->modinfo_attrs);
        return error;
}

static void mod_kobject_put(struct module *mod)
{
        DECLARE_COMPLETION_ONSTACK(c);

        mod->mkobj.kobj_completion = &c;
        kobject_put(&mod->mkobj.kobj);
        wait_for_completion(&c);
}

static int mod_sysfs_init(struct module *mod)
{
        int err;
        struct kobject *kobj;

        if (!module_kset) {
                pr_err("%s: module sysfs not initialized\n", mod->name);
                err = -EINVAL;
                goto out;
        }

        kobj = kset_find_obj(module_kset, mod->name);
        if (kobj) {
                pr_err("%s: module is already loaded\n", mod->name);
                kobject_put(kobj);
                err = -EINVAL;
                goto out;
        }

        mod->mkobj.mod = mod;

        memset(&mod->mkobj.kobj, 0, sizeof(mod->mkobj.kobj));
        mod->mkobj.kobj.kset = module_kset;
        err = kobject_init_and_add(&mod->mkobj.kobj, &module_ktype, NULL,
                                   "%s", mod->name);
        if (err)
                mod_kobject_put(mod);

out:
        return err;
}

int mod_sysfs_setup(struct module *mod,
                    const struct load_info *info,
                           struct kernel_param *kparam,
                           unsigned int num_params)
{
        int err;

        err = mod_sysfs_init(mod);
        if (err)
                goto out;

        mod->holders_dir = kobject_create_and_add("holders", &mod->mkobj.kobj);
        if (!mod->holders_dir) {
                err = -ENOMEM;
                goto out_unreg;
        }

        err = module_param_sysfs_setup(mod, kparam, num_params);
        if (err)
                goto out_unreg_holders;

        err = module_add_modinfo_attrs(mod);
        if (err)
                goto out_unreg_param;

        err = add_usage_links(mod);
        if (err)
                goto out_unreg_modinfo_attrs;

        err = add_sect_attrs(mod, info);
        if (err)
                goto out_del_usage_links;

        err = add_notes_attrs(mod, info);
        if (err)
                goto out_unreg_sect_attrs;

        return 0;

out_unreg_sect_attrs:
        remove_sect_attrs(mod);
out_del_usage_links:
        del_usage_links(mod);
out_unreg_modinfo_attrs:
        module_remove_modinfo_attrs(mod, -1);
out_unreg_param:
        module_param_sysfs_remove(mod);
out_unreg_holders:
        kobject_put(mod->holders_dir);
out_unreg:
        mod_kobject_put(mod);
out:
        return err;
}

static void mod_sysfs_fini(struct module *mod)
{
        remove_notes_attrs(mod);
        remove_sect_attrs(mod);
        mod_kobject_put(mod);
}

void mod_sysfs_teardown(struct module *mod)
{
        del_usage_links(mod);
        module_remove_modinfo_attrs(mod, -1);
        module_param_sysfs_remove(mod);
        kobject_put(mod->mkobj.drivers_dir);
        kobject_put(mod->holders_dir);
        mod_sysfs_fini(mod);
}

void init_param_lock(struct module *mod)
{
        mutex_init(&mod->param_lock);
}