LXR linux/net/sunrpc/sysctl.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * linux/net/sunrpc/sysctl.c
   4 *
   5 * Sysctl interface to sunrpc module.
   6 *
   7 * I would prefer to register the sunrpc table below sys/net, but that's
   8 * impossible at the moment.
   9 */
  10
  11#include <linux/types.h>
  12#include <linux/linkage.h>
  13#include <linux/ctype.h>
  14#include <linux/fs.h>
  15#include <linux/sysctl.h>
  16#include <linux/module.h>
  17
  18#include <linux/uaccess.h>
  19#include <linux/sunrpc/types.h>
  20#include <linux/sunrpc/sched.h>
  21#include <linux/sunrpc/stats.h>
  22#include <linux/sunrpc/svc_xprt.h>
  23
  24#include "netns.h"
  25
  26/*
  27 * Declare the debug flags here
  28 */
  29unsigned int    rpc_debug;
  30EXPORT_SYMBOL_GPL(rpc_debug);
  31
  32unsigned int    nfs_debug;
  33EXPORT_SYMBOL_GPL(nfs_debug);
  34
  35unsigned int    nfsd_debug;
  36EXPORT_SYMBOL_GPL(nfsd_debug);
  37
  38unsigned int    nlm_debug;
  39EXPORT_SYMBOL_GPL(nlm_debug);
  40
  41#if IS_ENABLED(CONFIG_SUNRPC_DEBUG)
  42
  43static struct ctl_table_header *sunrpc_table_header;
  44static struct ctl_table sunrpc_table[];
  45
  46void
  47rpc_register_sysctl(void)
  48{
  49        if (!sunrpc_table_header)
  50                sunrpc_table_header = register_sysctl_table(sunrpc_table);
  51}
  52
  53void
  54rpc_unregister_sysctl(void)
  55{
  56        if (sunrpc_table_header) {
  57                unregister_sysctl_table(sunrpc_table_header);
  58                sunrpc_table_header = NULL;
  59        }
  60}
  61
  62static int proc_do_xprt(struct ctl_table *table, int write,
  63                        void *buffer, size_t *lenp, loff_t *ppos)
  64{
  65        char tmpbuf[256];
  66        ssize_t len;
  67
  68        if (write || *ppos) {
  69                *lenp = 0;
  70                return 0;
  71        }
  72        len = svc_print_xprts(tmpbuf, sizeof(tmpbuf));
  73        len = memory_read_from_buffer(buffer, *lenp, ppos, tmpbuf, len);
  74
  75        if (len < 0) {
  76                *lenp = 0;
  77                return -EINVAL;
  78        }
  79        *lenp = len;
  80        return 0;
  81}
  82
  83static int
  84proc_dodebug(struct ctl_table *table, int write, void *buffer, size_t *lenp,
  85             loff_t *ppos)
  86{
  87        char            tmpbuf[20], *s = NULL;
  88        char *p;
  89        unsigned int    value;
  90        size_t          left, len;
  91
  92        if ((*ppos && !write) || !*lenp) {
  93                *lenp = 0;
  94                return 0;
  95        }
  96
  97        left = *lenp;
  98
  99        if (write) {
 100                p = buffer;
 101                while (left && isspace(*p)) {
 102                        left--;
 103                        p++;
 104                }
 105                if (!left)
 106                        goto done;
 107
 108                if (left > sizeof(tmpbuf) - 1)
 109                        return -EINVAL;
 110                memcpy(tmpbuf, p, left);
 111                tmpbuf[left] = '\0';
 112
 113                value = simple_strtol(tmpbuf, &s, 0);
 114                if (s) {
 115                        left -= (s - tmpbuf);
 116                        if (left && !isspace(*s))
 117                                return -EINVAL;
 118                        while (left && isspace(*s)) {
 119                                left--;
 120                                s++;
 121                        }
 122                } else
 123                        left = 0;
 124                *(unsigned int *) table->data = value;
 125                /* Display the RPC tasks on writing to rpc_debug */
 126                if (strcmp(table->procname, "rpc_debug") == 0)
 127                        rpc_show_tasks(&init_net);
 128        } else {
 129                len = sprintf(tmpbuf, "0x%04x", *(unsigned int *) table->data);
 130                if (len > left)
 131                        len = left;
 132                memcpy(buffer, tmpbuf, len);
 133                if ((left -= len) > 0) {
 134                        *((char *)buffer + len) = '\n';
 135                        left--;
 136                }
 137        }
 138
 139done:
 140        *lenp -= left;
 141        *ppos += *lenp;
 142        return 0;
 143}
 144
 145
 146static struct ctl_table debug_table[] = {
 147        {
 148                .procname       = "rpc_debug",
 149                .data           = &rpc_debug,
 150                .maxlen         = sizeof(int),
 151                .mode           = 0644,
 152                .proc_handler   = proc_dodebug
 153        },
 154        {
 155                .procname       = "nfs_debug",
 156                .data           = &nfs_debug,
 157                .maxlen         = sizeof(int),
 158                .mode           = 0644,
 159                .proc_handler   = proc_dodebug
 160        },
 161        {
 162                .procname       = "nfsd_debug",
 163                .data           = &nfsd_debug,
 164                .maxlen         = sizeof(int),
 165                .mode           = 0644,
 166                .proc_handler   = proc_dodebug
 167        },
 168        {
 169                .procname       = "nlm_debug",
 170                .data           = &nlm_debug,
 171                .maxlen         = sizeof(int),
 172                .mode           = 0644,
 173                .proc_handler   = proc_dodebug
 174        },
 175        {
 176                .procname       = "transports",
 177                .maxlen         = 256,
 178                .mode           = 0444,
 179                .proc_handler   = proc_do_xprt,
 180        },
 181        { }
 182};
 183
 184static struct ctl_table sunrpc_table[] = {
 185        {
 186                .procname       = "sunrpc",
 187                .mode           = 0555,
 188                .child          = debug_table
 189        },
 190        { }
 191};
 192
 193#endif
 194