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