// SPDX-License-Identifier: GPL-2.0
/*
 * Documentation/ABI/stable/sysfs-fs-orangefs:
 *
 * What:                /sys/fs/orangefs/perf_counter_reset
 * Date:                June 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      echo a 0 or a 1 into perf_counter_reset to
 *                      reset all the counters in
 *                      /sys/fs/orangefs/perf_counters
 *                      except ones with PINT_PERF_PRESERVE set.
 *
 *
 * What:                /sys/fs/orangefs/perf_counters/...
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Counters and settings for various caches.
 *                      Read only.
 *
 *
 * What:                /sys/fs/orangefs/perf_time_interval_secs
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Length of perf counter intervals in
 *                      seconds.
 *
 *
 * What:                /sys/fs/orangefs/perf_history_size
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      The perf_counters cache statistics have N, or
 *                      perf_history_size, samples. The default is
 *                      one.
 *
 *                      Every perf_time_interval_secs the (first)
 *                      samples are reset.
 *
 *                      If N is greater than one, the "current" set
 *                      of samples is reset, and the samples from the
 *                      other N-1 intervals remain available.
 *
 *
 * What:                /sys/fs/orangefs/op_timeout_secs
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Service operation timeout in seconds.
 *
 *
 * What:                /sys/fs/orangefs/slot_timeout_secs
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      "Slot" timeout in seconds. A "slot"
 *                      is an indexed buffer in the shared
 *                      memory segment used for communication
 *                      between the kernel module and userspace.
 *                      Slots are requested and waited for,
 *                      the wait times out after slot_timeout_secs.
 *
 * What:                /sys/fs/orangefs/cache_timeout_msecs
 * Date:                Mar 2018
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Time in milliseconds between which
 *                      orangefs_revalidate_mapping will invalidate the page
 *                      cache.
 *
 * What:                /sys/fs/orangefs/dcache_timeout_msecs
 * Date:                Jul 2016
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Time lookup is valid in milliseconds.
 *
 * What:                /sys/fs/orangefs/getattr_timeout_msecs
 * Date:                Jul 2016
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Time getattr is valid in milliseconds.
 *
 * What:                /sys/fs/orangefs/readahead_count
 * Date:                Aug 2016
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Readahead cache buffer count.
 *
 * What:                /sys/fs/orangefs/readahead_size
 * Date:                Aug 2016
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Readahead cache buffer size.
 *
 * What:                /sys/fs/orangefs/readahead_count_size
 * Date:                Aug 2016
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Readahead cache buffer count and size.
 *
 * What:                /sys/fs/orangefs/readahead_readcnt
 * Date:                Jan 2017
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Number of buffers (in multiples of readahead_size)
 *                      which can be read ahead for a single file at once.
 *
 * What:                /sys/fs/orangefs/acache/...
 * Date:                Jun 2015
 * Contact:             Martin Brandenburg <martin@omnibond.com>
 * Description:
 *                      Attribute cache configurable settings.
 *
 *
 * What:                /sys/fs/orangefs/ncache/...
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Name cache configurable settings.
 *
 *
 * What:                /sys/fs/orangefs/capcache/...
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Capability cache configurable settings.
 *
 *
 * What:                /sys/fs/orangefs/ccache/...
 * Date:                Jun 2015
 * Contact:             Mike Marshall <hubcap@omnibond.com>
 * Description:
 *                      Credential cache configurable settings.
 *
 */

#include <linux/fs.h>
#include <linux/kobject.h>
#include <linux/string.h>
#include <linux/sysfs.h>
#include <linux/module.h>
#include <linux/init.h>

#include "protocol.h"
#include "orangefs-kernel.h"
#include "orangefs-sysfs.h"

#define ORANGEFS_KOBJ_ID "orangefs"
#define ACACHE_KOBJ_ID "acache"
#define CAPCACHE_KOBJ_ID "capcache"
#define CCACHE_KOBJ_ID "ccache"
#define NCACHE_KOBJ_ID "ncache"
#define PC_KOBJ_ID "pc"
#define STATS_KOBJ_ID "stats"

/*
 * Every item calls orangefs_attr_show and orangefs_attr_store through
 * orangefs_sysfs_ops. They look at the orangefs_attributes further below to
 * call one of sysfs_int_show, sysfs_int_store, sysfs_service_op_show, or
 * sysfs_service_op_store.
 */

struct orangefs_attribute {
        struct attribute attr;
        ssize_t (*show)(struct kobject *kobj,
                        struct orangefs_attribute *attr,
                        char *buf);
        ssize_t (*store)(struct kobject *kobj,
                         struct orangefs_attribute *attr,
                         const char *buf,
                         size_t count);
};

static ssize_t orangefs_attr_show(struct kobject *kobj,
                                  struct attribute *attr,
                                  char *buf)
{
        struct orangefs_attribute *attribute;

        attribute = container_of(attr, struct orangefs_attribute, attr);
        if (!attribute->show)
                return -EIO;
        return attribute->show(kobj, attribute, buf);
}

static ssize_t orangefs_attr_store(struct kobject *kobj,
                                   struct attribute *attr,
                                   const char *buf,
                                   size_t len)
{
        struct orangefs_attribute *attribute;

        if (!strcmp(kobj->name, PC_KOBJ_ID) ||
            !strcmp(kobj->name, STATS_KOBJ_ID))
                return -EPERM;

        attribute = container_of(attr, struct orangefs_attribute, attr);
        if (!attribute->store)
                return -EIO;
        return attribute->store(kobj, attribute, buf, len);
}

static const struct sysfs_ops orangefs_sysfs_ops = {
        .show = orangefs_attr_show,
        .store = orangefs_attr_store,
};

static ssize_t sysfs_int_show(struct kobject *kobj,
    struct orangefs_attribute *attr, char *buf)
{
        int rc = -EIO;

        gossip_debug(GOSSIP_SYSFS_DEBUG, "sysfs_int_show: id:%s:\n",
            kobj->name);

        if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "op_timeout_secs")) {
                        rc = sysfs_emit(buf,
                                       "%d\n",
                                       op_timeout_secs);
                        goto out;
                } else if (!strcmp(attr->attr.name,
                                   "slot_timeout_secs")) {
                        rc = sysfs_emit(buf,
                                       "%d\n",
                                       slot_timeout_secs);
                        goto out;
                } else if (!strcmp(attr->attr.name,
                                   "cache_timeout_msecs")) {
                        rc = sysfs_emit(buf,
                                       "%d\n",
                                       orangefs_cache_timeout_msecs);
                        goto out;
                } else if (!strcmp(attr->attr.name,
                                   "dcache_timeout_msecs")) {
                        rc = sysfs_emit(buf,
                                       "%d\n",
                                       orangefs_dcache_timeout_msecs);
                        goto out;
                } else if (!strcmp(attr->attr.name,
                                   "getattr_timeout_msecs")) {
                        rc = sysfs_emit(buf,
                                       "%d\n",
                                       orangefs_getattr_timeout_msecs);
                        goto out;
                } else {
                        goto out;
                }

        } else if (!strcmp(kobj->name, STATS_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "reads")) {
                        rc = sysfs_emit(buf,
                                       "%lu\n",
                                       orangefs_stats.reads);
                        goto out;
                } else if (!strcmp(attr->attr.name, "writes")) {
                        rc = sysfs_emit(buf,
                                       "%lu\n",
                                       orangefs_stats.writes);
                        goto out;
                } else {
                        goto out;
                }
        }

out:

        return rc;
}

static ssize_t sysfs_int_store(struct kobject *kobj,
    struct orangefs_attribute *attr, const char *buf, size_t count)
{
        int rc = 0;

        gossip_debug(GOSSIP_SYSFS_DEBUG,
                     "sysfs_int_store: start attr->attr.name:%s: buf:%s:\n",
                     attr->attr.name, buf);

        if (!strcmp(attr->attr.name, "op_timeout_secs")) {
                rc = kstrtoint(buf, 0, &op_timeout_secs);
                goto out;
        } else if (!strcmp(attr->attr.name, "slot_timeout_secs")) {
                rc = kstrtoint(buf, 0, &slot_timeout_secs);
                goto out;
        } else if (!strcmp(attr->attr.name, "cache_timeout_msecs")) {
                rc = kstrtoint(buf, 0, &orangefs_cache_timeout_msecs);
                goto out;
        } else if (!strcmp(attr->attr.name, "dcache_timeout_msecs")) {
                rc = kstrtoint(buf, 0, &orangefs_dcache_timeout_msecs);
                goto out;
        } else if (!strcmp(attr->attr.name, "getattr_timeout_msecs")) {
                rc = kstrtoint(buf, 0, &orangefs_getattr_timeout_msecs);
                goto out;
        } else {
                goto out;
        }

out:
        if (rc)
                rc = -EINVAL;
        else
                rc = count;

        return rc;
}

/*
 * obtain attribute values from userspace with a service operation.
 */
static ssize_t sysfs_service_op_show(struct kobject *kobj,
    struct orangefs_attribute *attr, char *buf)
{
        struct orangefs_kernel_op_s *new_op = NULL;
        int rc = 0;
        char *ser_op_type = NULL;
        __u32 op_alloc_type;

        gossip_debug(GOSSIP_SYSFS_DEBUG,
                     "sysfs_service_op_show: id:%s:\n",
                     kobj->name);

        if (strcmp(kobj->name, PC_KOBJ_ID))
                op_alloc_type = ORANGEFS_VFS_OP_PARAM;
        else
                op_alloc_type = ORANGEFS_VFS_OP_PERF_COUNT;

        new_op = op_alloc(op_alloc_type);
        if (!new_op)
                return -ENOMEM;

        /* Can't do a service_operation if the client is not running... */
        rc = is_daemon_in_service();
        if (rc) {
                pr_info_ratelimited("%s: Client not running :%d:\n",
                        __func__,
                        is_daemon_in_service());
                goto out;
        }

        if (strcmp(kobj->name, PC_KOBJ_ID))
                new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_GET;

        if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
                /* Drop unsupported requests first. */
                if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
                    (!strcmp(attr->attr.name, "readahead_count") ||
                    !strcmp(attr->attr.name, "readahead_size") ||
                    !strcmp(attr->attr.name, "readahead_count_size") ||
                    !strcmp(attr->attr.name, "readahead_readcnt"))) {
                        rc = -EINVAL;
                        goto out;
                }

                if (!strcmp(attr->attr.name, "perf_history_size"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
                else if (!strcmp(attr->attr.name,
                                 "perf_time_interval_secs"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
                else if (!strcmp(attr->attr.name,
                                 "perf_counter_reset"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;

                else if (!strcmp(attr->attr.name,
                                 "readahead_count"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT;

                else if (!strcmp(attr->attr.name,
                                 "readahead_size"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_SIZE;

                else if (!strcmp(attr->attr.name,
                                 "readahead_count_size"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE;

                else if (!strcmp(attr->attr.name,
                                 "readahead_readcnt"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_READCNT;
        } else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "timeout_msecs"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;

                if (!strcmp(attr->attr.name, "hard_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;

                if (!strcmp(attr->attr.name, "soft_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;

                if (!strcmp(attr->attr.name, "reclaim_percentage"))
                        new_op->upcall.req.param.op =
                          ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;

        } else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "timeout_secs"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;

                if (!strcmp(attr->attr.name, "hard_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;

                if (!strcmp(attr->attr.name, "soft_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;

                if (!strcmp(attr->attr.name, "reclaim_percentage"))
                        new_op->upcall.req.param.op =
                          ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;

        } else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "timeout_secs"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;

                if (!strcmp(attr->attr.name, "hard_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;

                if (!strcmp(attr->attr.name, "soft_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;

                if (!strcmp(attr->attr.name, "reclaim_percentage"))
                        new_op->upcall.req.param.op =
                          ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;

        } else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "timeout_msecs"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;

                if (!strcmp(attr->attr.name, "hard_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;

                if (!strcmp(attr->attr.name, "soft_limit"))
                        new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;

                if (!strcmp(attr->attr.name, "reclaim_percentage"))
                        new_op->upcall.req.param.op =
                          ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;

        } else if (!strcmp(kobj->name, PC_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, ACACHE_KOBJ_ID))
                        new_op->upcall.req.perf_count.type =
                                ORANGEFS_PERF_COUNT_REQUEST_ACACHE;

                if (!strcmp(attr->attr.name, CAPCACHE_KOBJ_ID))
                        new_op->upcall.req.perf_count.type =
                                ORANGEFS_PERF_COUNT_REQUEST_CAPCACHE;

                if (!strcmp(attr->attr.name, NCACHE_KOBJ_ID))
                        new_op->upcall.req.perf_count.type =
                                ORANGEFS_PERF_COUNT_REQUEST_NCACHE;

        } else {
                gossip_err("sysfs_service_op_show: unknown kobj_id:%s:\n",
                           kobj->name);
                rc = -EINVAL;
                goto out;
        }


        if (strcmp(kobj->name, PC_KOBJ_ID))
                ser_op_type = "orangefs_param";
        else
                ser_op_type = "orangefs_perf_count";

        /*
         * The service_operation will return an errno return code on
         * error, and zero on success.
         */
        rc = service_operation(new_op, ser_op_type, ORANGEFS_OP_INTERRUPTIBLE);

out:
        if (!rc) {
                if (strcmp(kobj->name, PC_KOBJ_ID)) {
                        if (new_op->upcall.req.param.op ==
                            ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE) {
                                rc = sysfs_emit(buf, "%d %d\n",
                                    (int)new_op->downcall.resp.param.u.
                                    value32[0],
                                    (int)new_op->downcall.resp.param.u.
                                    value32[1]);
                        } else {
                                rc = sysfs_emit(buf, "%d\n",
                                    (int)new_op->downcall.resp.param.u.value64);
                        }
                } else {
                        rc = sysfs_emit(
                                buf,
                                "%s",
                                new_op->downcall.resp.perf_count.buffer);
                }
        }

        op_release(new_op);

        return rc;

}

/*
 * pass attribute values back to userspace with a service operation.
 *
 * We have to do a memory allocation, an sscanf and a service operation.
 * And we have to evaluate what the user entered, to make sure the
 * value is within the range supported by the attribute. So, there's
 * a lot of return code checking and mapping going on here.
 *
 * We want to return 1 if we think everything went OK, and
 * EINVAL if not.
 */
static ssize_t sysfs_service_op_store(struct kobject *kobj,
    struct orangefs_attribute *attr, const char *buf, size_t count)
{
        struct orangefs_kernel_op_s *new_op = NULL;
        int val = 0;
        int rc = 0;

        gossip_debug(GOSSIP_SYSFS_DEBUG,
                     "sysfs_service_op_store: id:%s:\n",
                     kobj->name);

        new_op = op_alloc(ORANGEFS_VFS_OP_PARAM);
        if (!new_op)
                return -EINVAL; /* sic */

        /* Can't do a service_operation if the client is not running... */
        rc = is_daemon_in_service();
        if (rc) {
                pr_info("%s: Client not running :%d:\n",
                        __func__,
                        is_daemon_in_service());
                goto out;
        }

        /*
         * The value we want to send back to userspace is in buf, unless this
         * there are two parameters, which is specially handled below.
         */
        if (strcmp(kobj->name, ORANGEFS_KOBJ_ID) ||
            strcmp(attr->attr.name, "readahead_count_size")) {
                rc = kstrtoint(buf, 0, &val);
                if (rc)
                        goto out;
        }

        new_op->upcall.req.param.type = ORANGEFS_PARAM_REQUEST_SET;

        if (!strcmp(kobj->name, ORANGEFS_KOBJ_ID)) {
                /* Drop unsupported requests first. */
                if (!(orangefs_features & ORANGEFS_FEATURE_READAHEAD) &&
                    (!strcmp(attr->attr.name, "readahead_count") ||
                    !strcmp(attr->attr.name, "readahead_size") ||
                    !strcmp(attr->attr.name, "readahead_count_size") ||
                    !strcmp(attr->attr.name, "readahead_readcnt"))) {
                        rc = -EINVAL;
                        goto out;
                }

                if (!strcmp(attr->attr.name, "perf_history_size")) {
                        if (val > 0) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_PERF_HISTORY_SIZE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "perf_time_interval_secs")) {
                        if (val > 0) {
                                new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_PERF_TIME_INTERVAL_SECS;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "perf_counter_reset")) {
                        if ((val == 0) || (val == 1)) {
                                new_op->upcall.req.param.op =
                                        ORANGEFS_PARAM_REQUEST_OP_PERF_RESET;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "readahead_count")) {
                        if ((val >= 0)) {
                                new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "readahead_size")) {
                        if ((val >= 0)) {
                                new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_SIZE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "readahead_count_size")) {
                        int val1, val2;
                        rc = sscanf(buf, "%d %d", &val1, &val2);
                        if (rc < 2) {
                                rc = 0;
                                goto out;
                        }
                        if ((val1 >= 0) && (val2 >= 0)) {
                                new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_COUNT_SIZE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                        new_op->upcall.req.param.u.value32[0] = val1;
                        new_op->upcall.req.param.u.value32[1] = val2;
                        goto value_set;
                } else if (!strcmp(attr->attr.name,
                                   "readahead_readcnt")) {
                        if ((val >= 0)) {
                                new_op->upcall.req.param.op =
                                ORANGEFS_PARAM_REQUEST_OP_READAHEAD_READCNT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                }

        } else if (!strcmp(kobj->name, ACACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "hard_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_ACACHE_HARD_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "soft_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_ACACHE_SOFT_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "reclaim_percentage")) {
                        if ((val > -1) && (val < 101)) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_ACACHE_RECLAIM_PERCENTAGE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "timeout_msecs")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_ACACHE_TIMEOUT_MSECS;
                        } else {
                                rc = 0;
                                goto out;
                        }
                }

        } else if (!strcmp(kobj->name, CAPCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "hard_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_HARD_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "soft_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_SOFT_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "reclaim_percentage")) {
                        if ((val > -1) && (val < 101)) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_RECLAIM_PERCENTAGE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "timeout_secs")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CAPCACHE_TIMEOUT_SECS;
                        } else {
                                rc = 0;
                                goto out;
                        }
                }

        } else if (!strcmp(kobj->name, CCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "hard_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CCACHE_HARD_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "soft_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CCACHE_SOFT_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "reclaim_percentage")) {
                        if ((val > -1) && (val < 101)) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CCACHE_RECLAIM_PERCENTAGE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "timeout_secs")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_CCACHE_TIMEOUT_SECS;
                        } else {
                                rc = 0;
                                goto out;
                        }
                }

        } else if (!strcmp(kobj->name, NCACHE_KOBJ_ID)) {
                if (!strcmp(attr->attr.name, "hard_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_NCACHE_HARD_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "soft_limit")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_NCACHE_SOFT_LIMIT;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name,
                                   "reclaim_percentage")) {
                        if ((val > -1) && (val < 101)) {
                                new_op->upcall.req.param.op =
                                        ORANGEFS_PARAM_REQUEST_OP_NCACHE_RECLAIM_PERCENTAGE;
                        } else {
                                rc = 0;
                                goto out;
                        }
                } else if (!strcmp(attr->attr.name, "timeout_msecs")) {
                        if (val > -1) {
                                new_op->upcall.req.param.op =
                                  ORANGEFS_PARAM_REQUEST_OP_NCACHE_TIMEOUT_MSECS;
                        } else {
                                rc = 0;
                                goto out;
                        }
                }

        } else {
                gossip_err("sysfs_service_op_store: unknown kobj_id:%s:\n",
                           kobj->name);
                rc = -EINVAL;
                goto out;
        }

        new_op->upcall.req.param.u.value64 = val;
value_set:

        /*
         * The service_operation will return a errno return code on
         * error, and zero on success.
         */
        rc = service_operation(new_op, "orangefs_param", ORANGEFS_OP_INTERRUPTIBLE);

        if (rc < 0) {
                gossip_err("sysfs_service_op_store: service op returned:%d:\n",
                        rc);
                rc = 0;
        } else {
                rc = count;
        }

out:
        op_release(new_op);

        if (rc == -ENOMEM || rc == 0)
                rc = -EINVAL;

        return rc;
}

static struct orangefs_attribute op_timeout_secs_attribute =
        __ATTR(op_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);

static struct orangefs_attribute slot_timeout_secs_attribute =
        __ATTR(slot_timeout_secs, 0664, sysfs_int_show, sysfs_int_store);

static struct orangefs_attribute cache_timeout_msecs_attribute =
        __ATTR(cache_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);

static struct orangefs_attribute dcache_timeout_msecs_attribute =
        __ATTR(dcache_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);

static struct orangefs_attribute getattr_timeout_msecs_attribute =
        __ATTR(getattr_timeout_msecs, 0664, sysfs_int_show, sysfs_int_store);

static struct orangefs_attribute readahead_count_attribute =
        __ATTR(readahead_count, 0664, sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute readahead_size_attribute =
        __ATTR(readahead_size, 0664, sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute readahead_count_size_attribute =
        __ATTR(readahead_count_size, 0664, sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute readahead_readcnt_attribute =
        __ATTR(readahead_readcnt, 0664, sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute perf_counter_reset_attribute =
        __ATTR(perf_counter_reset,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute perf_history_size_attribute =
        __ATTR(perf_history_size,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute perf_time_interval_secs_attribute =
        __ATTR(perf_time_interval_secs,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct attribute *orangefs_default_attrs[] = {
        &op_timeout_secs_attribute.attr,
        &slot_timeout_secs_attribute.attr,
        &cache_timeout_msecs_attribute.attr,
        &dcache_timeout_msecs_attribute.attr,
        &getattr_timeout_msecs_attribute.attr,
        &readahead_count_attribute.attr,
        &readahead_size_attribute.attr,
        &readahead_count_size_attribute.attr,
        &readahead_readcnt_attribute.attr,
        &perf_counter_reset_attribute.attr,
        &perf_history_size_attribute.attr,
        &perf_time_interval_secs_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(orangefs_default);

static struct kobject *orangefs_obj;

static void orangefs_obj_release(struct kobject *kobj)
{
        kfree(orangefs_obj);
        orangefs_obj = NULL;
}

static const struct kobj_type orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = orangefs_default_groups,
        .release = orangefs_obj_release,
};

static struct orangefs_attribute acache_hard_limit_attribute =
        __ATTR(hard_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute acache_reclaim_percent_attribute =
        __ATTR(reclaim_percentage,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute acache_soft_limit_attribute =
        __ATTR(soft_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute acache_timeout_msecs_attribute =
        __ATTR(timeout_msecs,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct attribute *acache_orangefs_default_attrs[] = {
        &acache_hard_limit_attribute.attr,
        &acache_reclaim_percent_attribute.attr,
        &acache_soft_limit_attribute.attr,
        &acache_timeout_msecs_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(acache_orangefs_default);

static struct kobject *acache_orangefs_obj;

static void acache_orangefs_obj_release(struct kobject *kobj)
{
        kfree(acache_orangefs_obj);
        acache_orangefs_obj = NULL;
}

static const struct kobj_type acache_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = acache_orangefs_default_groups,
        .release = acache_orangefs_obj_release,
};

static struct orangefs_attribute capcache_hard_limit_attribute =
        __ATTR(hard_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute capcache_reclaim_percent_attribute =
        __ATTR(reclaim_percentage,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute capcache_soft_limit_attribute =
        __ATTR(soft_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute capcache_timeout_secs_attribute =
        __ATTR(timeout_secs,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct attribute *capcache_orangefs_default_attrs[] = {
        &capcache_hard_limit_attribute.attr,
        &capcache_reclaim_percent_attribute.attr,
        &capcache_soft_limit_attribute.attr,
        &capcache_timeout_secs_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(capcache_orangefs_default);

static struct kobject *capcache_orangefs_obj;

static void capcache_orangefs_obj_release(struct kobject *kobj)
{
        kfree(capcache_orangefs_obj);
        capcache_orangefs_obj = NULL;
}

static const struct kobj_type capcache_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = capcache_orangefs_default_groups,
        .release = capcache_orangefs_obj_release,
};

static struct orangefs_attribute ccache_hard_limit_attribute =
        __ATTR(hard_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ccache_reclaim_percent_attribute =
        __ATTR(reclaim_percentage,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ccache_soft_limit_attribute =
        __ATTR(soft_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ccache_timeout_secs_attribute =
        __ATTR(timeout_secs,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct attribute *ccache_orangefs_default_attrs[] = {
        &ccache_hard_limit_attribute.attr,
        &ccache_reclaim_percent_attribute.attr,
        &ccache_soft_limit_attribute.attr,
        &ccache_timeout_secs_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(ccache_orangefs_default);

static struct kobject *ccache_orangefs_obj;

static void ccache_orangefs_obj_release(struct kobject *kobj)
{
        kfree(ccache_orangefs_obj);
        ccache_orangefs_obj = NULL;
}

static const struct kobj_type ccache_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = ccache_orangefs_default_groups,
        .release = ccache_orangefs_obj_release,
};

static struct orangefs_attribute ncache_hard_limit_attribute =
        __ATTR(hard_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ncache_reclaim_percent_attribute =
        __ATTR(reclaim_percentage,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ncache_soft_limit_attribute =
        __ATTR(soft_limit,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct orangefs_attribute ncache_timeout_msecs_attribute =
        __ATTR(timeout_msecs,
               0664,
               sysfs_service_op_show,
               sysfs_service_op_store);

static struct attribute *ncache_orangefs_default_attrs[] = {
        &ncache_hard_limit_attribute.attr,
        &ncache_reclaim_percent_attribute.attr,
        &ncache_soft_limit_attribute.attr,
        &ncache_timeout_msecs_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(ncache_orangefs_default);

static struct kobject *ncache_orangefs_obj;

static void ncache_orangefs_obj_release(struct kobject *kobj)
{
        kfree(ncache_orangefs_obj);
        ncache_orangefs_obj = NULL;
}

static const struct kobj_type ncache_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = ncache_orangefs_default_groups,
        .release = ncache_orangefs_obj_release,
};

static struct orangefs_attribute pc_acache_attribute =
        __ATTR(acache,
               0664,
               sysfs_service_op_show,
               NULL);

static struct orangefs_attribute pc_capcache_attribute =
        __ATTR(capcache,
               0664,
               sysfs_service_op_show,
               NULL);

static struct orangefs_attribute pc_ncache_attribute =
        __ATTR(ncache,
               0664,
               sysfs_service_op_show,
               NULL);

static struct attribute *pc_orangefs_default_attrs[] = {
        &pc_acache_attribute.attr,
        &pc_capcache_attribute.attr,
        &pc_ncache_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(pc_orangefs_default);

static struct kobject *pc_orangefs_obj;

static void pc_orangefs_obj_release(struct kobject *kobj)
{
        kfree(pc_orangefs_obj);
        pc_orangefs_obj = NULL;
}

static const struct kobj_type pc_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = pc_orangefs_default_groups,
        .release = pc_orangefs_obj_release,
};

static struct orangefs_attribute stats_reads_attribute =
        __ATTR(reads,
               0664,
               sysfs_int_show,
               NULL);

static struct orangefs_attribute stats_writes_attribute =
        __ATTR(writes,
               0664,
               sysfs_int_show,
               NULL);

static struct attribute *stats_orangefs_default_attrs[] = {
        &stats_reads_attribute.attr,
        &stats_writes_attribute.attr,
        NULL,
};
ATTRIBUTE_GROUPS(stats_orangefs_default);

static struct kobject *stats_orangefs_obj;

static void stats_orangefs_obj_release(struct kobject *kobj)
{
        kfree(stats_orangefs_obj);
        stats_orangefs_obj = NULL;
}

static const struct kobj_type stats_orangefs_ktype = {
        .sysfs_ops = &orangefs_sysfs_ops,
        .default_groups = stats_orangefs_default_groups,
        .release = stats_orangefs_obj_release,
};

int orangefs_sysfs_init(void)
{
        int rc = -EINVAL;

        gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_init: start\n");

        /* create /sys/fs/orangefs. */
        orangefs_obj = kzalloc_obj(*orangefs_obj);
        if (!orangefs_obj)
                goto out;

        rc = kobject_init_and_add(orangefs_obj,
                                  &orangefs_ktype,
                                  fs_kobj,
                                  ORANGEFS_KOBJ_ID);

        if (rc)
                goto ofs_obj_bail;

        kobject_uevent(orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/acache. */
        acache_orangefs_obj = kzalloc_obj(*acache_orangefs_obj);
        if (!acache_orangefs_obj) {
                rc = -EINVAL;
                goto ofs_obj_bail;
        }

        rc = kobject_init_and_add(acache_orangefs_obj,
                                  &acache_orangefs_ktype,
                                  orangefs_obj,
                                  ACACHE_KOBJ_ID);

        if (rc)
                goto acache_obj_bail;

        kobject_uevent(acache_orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/capcache. */
        capcache_orangefs_obj = kzalloc_obj(*capcache_orangefs_obj);
        if (!capcache_orangefs_obj) {
                rc = -EINVAL;
                goto acache_obj_bail;
        }

        rc = kobject_init_and_add(capcache_orangefs_obj,
                                  &capcache_orangefs_ktype,
                                  orangefs_obj,
                                  CAPCACHE_KOBJ_ID);
        if (rc)
                goto capcache_obj_bail;

        kobject_uevent(capcache_orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/ccache. */
        ccache_orangefs_obj = kzalloc_obj(*ccache_orangefs_obj);
        if (!ccache_orangefs_obj) {
                rc = -EINVAL;
                goto capcache_obj_bail;
        }

        rc = kobject_init_and_add(ccache_orangefs_obj,
                                  &ccache_orangefs_ktype,
                                  orangefs_obj,
                                  CCACHE_KOBJ_ID);
        if (rc)
                goto ccache_obj_bail;

        kobject_uevent(ccache_orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/ncache. */
        ncache_orangefs_obj = kzalloc_obj(*ncache_orangefs_obj);
        if (!ncache_orangefs_obj) {
                rc = -EINVAL;
                goto ccache_obj_bail;
        }

        rc = kobject_init_and_add(ncache_orangefs_obj,
                                  &ncache_orangefs_ktype,
                                  orangefs_obj,
                                  NCACHE_KOBJ_ID);

        if (rc)
                goto ncache_obj_bail;

        kobject_uevent(ncache_orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/perf_counters. */
        pc_orangefs_obj = kzalloc_obj(*pc_orangefs_obj);
        if (!pc_orangefs_obj) {
                rc = -EINVAL;
                goto ncache_obj_bail;
        }

        rc = kobject_init_and_add(pc_orangefs_obj,
                                  &pc_orangefs_ktype,
                                  orangefs_obj,
                                  "perf_counters");

        if (rc)
                goto pc_obj_bail;

        kobject_uevent(pc_orangefs_obj, KOBJ_ADD);

        /* create /sys/fs/orangefs/stats. */
        stats_orangefs_obj = kzalloc_obj(*stats_orangefs_obj);
        if (!stats_orangefs_obj) {
                rc = -EINVAL;
                goto pc_obj_bail;
        }

        rc = kobject_init_and_add(stats_orangefs_obj,
                                  &stats_orangefs_ktype,
                                  orangefs_obj,
                                  STATS_KOBJ_ID);

        if (rc)
                goto stats_obj_bail;

        kobject_uevent(stats_orangefs_obj, KOBJ_ADD);
        goto out;

stats_obj_bail:
                kobject_put(stats_orangefs_obj);
pc_obj_bail:
                kobject_put(pc_orangefs_obj);
ncache_obj_bail:
                kobject_put(ncache_orangefs_obj);
ccache_obj_bail:
                kobject_put(ccache_orangefs_obj);
capcache_obj_bail:
                kobject_put(capcache_orangefs_obj);
acache_obj_bail:
                kobject_put(acache_orangefs_obj);
ofs_obj_bail:
                kobject_put(orangefs_obj);
out:
        return rc;
}

void orangefs_sysfs_exit(void)
{
        gossip_debug(GOSSIP_SYSFS_DEBUG, "orangefs_sysfs_exit: start\n");
        kobject_put(acache_orangefs_obj);
        kobject_put(capcache_orangefs_obj);
        kobject_put(ccache_orangefs_obj);
        kobject_put(ncache_orangefs_obj);
        kobject_put(pc_orangefs_obj);
        kobject_put(stats_orangefs_obj);
        kobject_put(orangefs_obj);
}