drivers/s390/net/ctcm_sysfs.c

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