drivers/s390/net/ctcm_sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright IBM Corp. 2007, 2007
   4  * Authors:     Peter Tiedemann (ptiedem@de.ibm.com)
   5  *
   6  */
   7
   8 #undef DEBUG
   9 #undef DEBUGDATA
  10 #undef DEBUGCCW
  11
  12 #define KMSG_COMPONENT "ctcm"
  13 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
  14
  15 #include <linux/device.h>
  16 #include <linux/sysfs.h>
  17 #include <linux/slab.h>
  18 #include "ctcm_main.h"
  19
  20 /*
  21  * sysfs attributes
  22  */
  23
  24 static ssize_t ctcm_buffer_show(struct device *dev,
  25                                 struct device_attribute *attr, char *buf)
  26 {
  27         struct ctcm_priv *priv = dev_get_drvdata(dev);
  28
  29         if (!priv)
  30                 return -ENODEV;
  31         return sprintf(buf, "%d\n", priv->buffer_size);
  32 }
  33
  34 static ssize_t ctcm_buffer_write(struct device *dev,
  35                 struct device_attribute *attr, const char *buf, size_t count)
  36 {
  37         struct net_device *ndev;
  38         unsigned int bs1;
  39         struct ctcm_priv *priv = dev_get_drvdata(dev);
  40         int rc;
  41
  42         if (!(priv && priv->channel[CTCM_READ] &&
  43               priv->channel[CTCM_READ]->netdev)) {
  44                 CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
  45                 return -ENODEV;
  46         }
  47         ndev = priv->channel[CTCM_READ]->netdev;
  48
  49         rc = kstrtouint(buf, 0, &bs1);
  50         if (rc)
  51                 goto einval;
  52         if (bs1 > CTCM_BUFSIZE_LIMIT)
  53                                         goto einval;
  54         if (bs1 < (576 + LL_HEADER_LENGTH + 2))
  55                                         goto einval;
  56         priv->buffer_size = bs1;        /* just to overwrite the default */
  57
  58         if ((ndev->flags & IFF_RUNNING) &&
  59             (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
  60                                         goto einval;
  61
  62         priv->channel[CTCM_READ]->max_bufsize = bs1;
  63         priv->channel[CTCM_WRITE]->max_bufsize = bs1;
  64         if (!(ndev->flags & IFF_RUNNING))
  65                 ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
  66         priv->channel[CTCM_READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
  67         priv->channel[CTCM_WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
  68
  69         CTCM_DBF_DEV(SETUP, ndev, buf);
  70         return count;
  71
  72 einval:
  73         CTCM_DBF_DEV(SETUP, ndev, "buff_err");
  74         return -EINVAL;
  75 }
  76
  77 static void ctcm_print_statistics(struct ctcm_priv *priv)
  78 {
  79         char *sbuf;
  80         char *p;
  81
  82         if (!priv)
  83                 return;
  84         sbuf = kmalloc(2048, GFP_KERNEL);
  85         if (sbuf == NULL)
  86                 return;
  87         p = sbuf;
  88
  89         p += sprintf(p, "  Device FSM state: %s\n",
  90                      fsm_getstate_str(priv->fsm));
  91         p += sprintf(p, "  RX channel FSM state: %s\n",
  92                      fsm_getstate_str(priv->channel[CTCM_READ]->fsm));
  93         p += sprintf(p, "  TX channel FSM state: %s\n",
  94                      fsm_getstate_str(priv->channel[CTCM_WRITE]->fsm));
  95         p += sprintf(p, "  Max. TX buffer used: %ld\n",
  96                      priv->channel[WRITE]->prof.maxmulti);
  97         p += sprintf(p, "  Max. chained SKBs: %ld\n",
  98                      priv->channel[WRITE]->prof.maxcqueue);
  99         p += sprintf(p, "  TX single write ops: %ld\n",
 100                      priv->channel[WRITE]->prof.doios_single);
 101         p += sprintf(p, "  TX multi write ops: %ld\n",
 102                      priv->channel[WRITE]->prof.doios_multi);
 103         p += sprintf(p, "  Netto bytes written: %ld\n",
 104                      priv->channel[WRITE]->prof.txlen);
 105         p += sprintf(p, "  Max. TX IO-time: %u\n",
 106                      jiffies_to_usecs(priv->channel[WRITE]->prof.tx_time));
 107
 108         printk(KERN_INFO "Statistics for %s:\n%s",
 109                                 priv->channel[CTCM_WRITE]->netdev->name, sbuf);
 110         kfree(sbuf);
 111         return;
 112 }
 113
 114 static ssize_t stats_show(struct device *dev,
 115                           struct device_attribute *attr, char *buf)
 116 {
 117         struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
 118         struct ctcm_priv *priv = dev_get_drvdata(dev);
 119
 120         if (!priv || gdev->state != CCWGROUP_ONLINE)
 121                 return -ENODEV;
 122         ctcm_print_statistics(priv);
 123         return sprintf(buf, "0\n");
 124 }
 125
 126 static ssize_t stats_write(struct device *dev, struct device_attribute *attr,
 127                                 const char *buf, size_t count)
 128 {
 129         struct ctcm_priv *priv = dev_get_drvdata(dev);
 130         if (!priv)
 131                 return -ENODEV;
 132         /* Reset statistics */
 133         memset(&priv->channel[WRITE]->prof, 0,
 134                                 sizeof(priv->channel[CTCM_WRITE]->prof));
 135         return count;
 136 }
 137
 138 static ssize_t ctcm_proto_show(struct device *dev,
 139                                 struct device_attribute *attr, char *buf)
 140 {
 141         struct ctcm_priv *priv = dev_get_drvdata(dev);
 142         if (!priv)
 143                 return -ENODEV;
 144
 145         return sprintf(buf, "%d\n", priv->protocol);
 146 }
 147
 148 static ssize_t ctcm_proto_store(struct device *dev,
 149                 struct device_attribute *attr, const char *buf, size_t count)
 150 {
 151         int value, rc;
 152         struct ctcm_priv *priv = dev_get_drvdata(dev);
 153
 154         if (!priv)
 155                 return -ENODEV;
 156         rc = kstrtoint(buf, 0, &value);
 157         if (rc ||
 158             !((value == CTCM_PROTO_S390)  ||
 159               (value == CTCM_PROTO_LINUX) ||
 160               (value == CTCM_PROTO_MPC) ||
 161               (value == CTCM_PROTO_OS390)))
 162                 return -EINVAL;
 163         priv->protocol = value;
 164         CTCM_DBF_DEV(SETUP, dev, buf);
 165
 166         return count;
 167 }
 168
 169 static const char *ctcm_type[] = {
 170         "not a channel",
 171         "CTC/A",
 172         "FICON channel",
 173         "ESCON channel",
 174         "unknown channel type",
 175         "unsupported channel type",
 176 };
 177
 178 static ssize_t ctcm_type_show(struct device *dev,
 179                                 struct device_attribute *attr, char *buf)
 180 {
 181         struct ccwgroup_device *cgdev;
 182
 183         cgdev = to_ccwgroupdev(dev);
 184         if (!cgdev)
 185                 return -ENODEV;
 186
 187         return sprintf(buf, "%s\n",
 188                         ctcm_type[cgdev->cdev[0]->id.driver_info]);
 189 }
 190
 191 static DEVICE_ATTR(buffer, 0644, ctcm_buffer_show, ctcm_buffer_write);
 192 static DEVICE_ATTR(protocol, 0644, ctcm_proto_show, ctcm_proto_store);
 193 static DEVICE_ATTR(type, 0444, ctcm_type_show, NULL);
 194 static DEVICE_ATTR(stats, 0644, stats_show, stats_write);
 195
 196 static struct attribute *ctcm_attr[] = {
 197         &dev_attr_protocol.attr,
 198         &dev_attr_type.attr,
 199         &dev_attr_buffer.attr,
 200         &dev_attr_stats.attr,
 201         NULL,
 202 };
 203
 204 static struct attribute_group ctcm_attr_group = {
 205         .attrs = ctcm_attr,
 206 };
 207 const struct attribute_group *ctcm_attr_groups[] = {
 208         &ctcm_attr_group,
 209         NULL,
 210 };