[linux-block.git] / drivers / s390 / net / ctcm_sysfs.c

// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright IBM Corp. 2007, 2007
 * Authors:	Peter Tiedemann (ptiedem@de.ibm.com)
 *
 */

#undef DEBUG
#undef DEBUGDATA
#undef DEBUGCCW

#define KMSG_COMPONENT "ctcm"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/device.h>
#include <linux/sysfs.h>
#include <linux/slab.h>
#include "ctcm_main.h"

/*
 * sysfs attributes
 */

static ssize_t ctcm_buffer_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ctcm_priv *priv = dev_get_drvdata(dev);

	if (!priv)
		return -ENODEV;
	return sprintf(buf, "%d\n", priv->buffer_size);
}

static ssize_t ctcm_buffer_write(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	struct net_device *ndev;
	unsigned int bs1;
	struct ctcm_priv *priv = dev_get_drvdata(dev);
	int rc;

	if (!(priv && priv->channel[CTCM_READ] &&
	      priv->channel[CTCM_READ]->netdev)) {
		CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
		return -ENODEV;
	}
	ndev = priv->channel[CTCM_READ]->netdev;

	rc = kstrtouint(buf, 0, &bs1);
	if (rc)
		goto einval;
	if (bs1 > CTCM_BUFSIZE_LIMIT)
					goto einval;
	if (bs1 < (576 + LL_HEADER_LENGTH + 2))
					goto einval;
	priv->buffer_size = bs1;	/* just to overwrite the default */

	if ((ndev->flags & IFF_RUNNING) &&
	    (bs1 < (ndev->mtu + LL_HEADER_LENGTH + 2)))
					goto einval;

	priv->channel[CTCM_READ]->max_bufsize = bs1;
	priv->channel[CTCM_WRITE]->max_bufsize = bs1;
	if (!(ndev->flags & IFF_RUNNING))
		ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
	priv->channel[CTCM_READ]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;
	priv->channel[CTCM_WRITE]->flags |= CHANNEL_FLAGS_BUFSIZE_CHANGED;

	CTCM_DBF_DEV(SETUP, ndev, buf);
	return count;

einval:
	CTCM_DBF_DEV(SETUP, ndev, "buff_err");
	return -EINVAL;
}

static void ctcm_print_statistics(struct ctcm_priv *priv)
{
	char *sbuf;
	char *p;

	if (!priv)
		return;
	sbuf = kmalloc(2048, GFP_KERNEL);
	if (sbuf == NULL)
		return;
	p = sbuf;

	p += sprintf(p, "  Device FSM state: %s\n",
		     fsm_getstate_str(priv->fsm));
	p += sprintf(p, "  RX channel FSM state: %s\n",
		     fsm_getstate_str(priv->channel[CTCM_READ]->fsm));
	p += sprintf(p, "  TX channel FSM state: %s\n",
		     fsm_getstate_str(priv->channel[CTCM_WRITE]->fsm));
	p += sprintf(p, "  Max. TX buffer used: %ld\n",
		     priv->channel[WRITE]->prof.maxmulti);
	p += sprintf(p, "  Max. chained SKBs: %ld\n",
		     priv->channel[WRITE]->prof.maxcqueue);
	p += sprintf(p, "  TX single write ops: %ld\n",
		     priv->channel[WRITE]->prof.doios_single);
	p += sprintf(p, "  TX multi write ops: %ld\n",
		     priv->channel[WRITE]->prof.doios_multi);
	p += sprintf(p, "  Netto bytes written: %ld\n",
		     priv->channel[WRITE]->prof.txlen);
	p += sprintf(p, "  Max. TX IO-time: %u\n",
		     jiffies_to_usecs(priv->channel[WRITE]->prof.tx_time));

	printk(KERN_INFO "Statistics for %s:\n%s",
				priv->channel[CTCM_WRITE]->netdev->name, sbuf);
	kfree(sbuf);
	return;
}

static ssize_t stats_show(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
	struct ctcm_priv *priv = dev_get_drvdata(dev);

	if (!priv || gdev->state != CCWGROUP_ONLINE)
		return -ENODEV;
	ctcm_print_statistics(priv);
	return sprintf(buf, "0\n");
}

static ssize_t stats_write(struct device *dev, struct device_attribute *attr,
				const char *buf, size_t count)
{
	struct ctcm_priv *priv = dev_get_drvdata(dev);
	if (!priv)
		return -ENODEV;
	/* Reset statistics */
	memset(&priv->channel[WRITE]->prof, 0,
				sizeof(priv->channel[CTCM_WRITE]->prof));
	return count;
}

static ssize_t ctcm_proto_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ctcm_priv *priv = dev_get_drvdata(dev);
	if (!priv)
		return -ENODEV;

	return sprintf(buf, "%d\n", priv->protocol);
}

static ssize_t ctcm_proto_store(struct device *dev,
		struct device_attribute *attr, const char *buf, size_t count)
{
	int value, rc;
	struct ctcm_priv *priv = dev_get_drvdata(dev);

	if (!priv)
		return -ENODEV;
	rc = kstrtoint(buf, 0, &value);
	if (rc ||
	    !((value == CTCM_PROTO_S390)  ||
	      (value == CTCM_PROTO_LINUX) ||
	      (value == CTCM_PROTO_MPC) ||
	      (value == CTCM_PROTO_OS390)))
		return -EINVAL;
	priv->protocol = value;
	CTCM_DBF_DEV(SETUP, dev, buf);

	return count;
}

static const char *ctcm_type[] = {
	"not a channel",
	"CTC/A",
	"FICON channel",
	"ESCON channel",
	"unknown channel type",
	"unsupported channel type",
};

static ssize_t ctcm_type_show(struct device *dev,
				struct device_attribute *attr, char *buf)
{
	struct ccwgroup_device *cgdev;

	cgdev = to_ccwgroupdev(dev);
	if (!cgdev)
		return -ENODEV;

	return sprintf(buf, "%s\n",
			ctcm_type[cgdev->cdev[0]->id.driver_info]);
}

static DEVICE_ATTR(buffer, 0644, ctcm_buffer_show, ctcm_buffer_write);
static DEVICE_ATTR(protocol, 0644, ctcm_proto_show, ctcm_proto_store);
static DEVICE_ATTR(type, 0444, ctcm_type_show, NULL);
static DEVICE_ATTR(stats, 0644, stats_show, stats_write);

static struct attribute *ctcm_attr[] = {
	&dev_attr_protocol.attr,
	&dev_attr_type.attr,
	&dev_attr_buffer.attr,
	&dev_attr_stats.attr,
	NULL,
};

static struct attribute_group ctcm_attr_group = {
	.attrs = ctcm_attr,
};
const struct attribute_group *ctcm_attr_groups[] = {
	&ctcm_attr_group,
	NULL,
};
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
293d984f	2	/*
293d984f PT	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
2a7c6f2c PT	12	#define KMSG_COMPONENT "ctcm"
	13	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	14
20cdffa4	15	#include <linux/device.h>
293d984f	16	#include <linux/sysfs.h>
5a0e3ad6	17	#include <linux/slab.h>
293d984f PT	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;
a68be015	38	unsigned int bs1;
293d984f	39	struct ctcm_priv *priv = dev_get_drvdata(dev);
a68be015	40	int rc;
293d984f	41
2c50c686 AW	42	if (!(priv && priv->channel[CTCM_READ] &&
2c50c686 AW	43	priv->channel[CTCM_READ]->netdev)) {
293d984f PT	44	CTCM_DBF_TEXT(SETUP, CTC_DBF_ERROR, "bfnondev");
	45	return -ENODEV;
	46	}
2c50c686	47	ndev = priv->channel[CTCM_READ]->netdev;
293d984f	48
652d77ba TR	49	rc = kstrtouint(buf, 0, &bs1);
652d77ba TR	50	if (rc)
a68be015	51	goto einval;
293d984f PT	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
3c09e264 UB	62	priv->channel[CTCM_READ]->max_bufsize = bs1;
3c09e264 UB	63	priv->channel[CTCM_WRITE]->max_bufsize = bs1;
293d984f PT	64	if (!(ndev->flags & IFF_RUNNING))
293d984f PT	65	ndev->mtu = bs1 - LL_HEADER_LENGTH - 2;
3c09e264 UB	66	priv->channel[CTCM_READ]->flags \|= CHANNEL_FLAGS_BUFSIZE_CHANGED;
3c09e264 UB	67	priv->channel[CTCM_WRITE]->flags \|= CHANNEL_FLAGS_BUFSIZE_CHANGED;
293d984f PT	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",
3c09e264	92	fsm_getstate_str(priv->channel[CTCM_READ]->fsm));
293d984f	93	p += sprintf(p, " TX channel FSM state: %s\n",
3c09e264	94	fsm_getstate_str(priv->channel[CTCM_WRITE]->fsm));
293d984f PT	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);
ee6edb97 AM	105	p += sprintf(p, " Max. TX IO-time: %u\n",
ee6edb97 AM	106	jiffies_to_usecs(priv->channel[WRITE]->prof.tx_time));
293d984f PT	107
293d984f PT	108	printk(KERN_INFO "Statistics for %s:\n%s",
3c09e264	109	priv->channel[CTCM_WRITE]->netdev->name, sbuf);
293d984f PT	110	kfree(sbuf);
	111	return;
	112	}
	113
	114	static ssize_t stats_show(struct device *dev,
20cdffa4	115	struct device_attribute attr, char buf)
293d984f	116	{
20cdffa4	117	struct ccwgroup_device *gdev = to_ccwgroupdev(dev);
293d984f	118	struct ctcm_priv *priv = dev_get_drvdata(dev);
20cdffa4 SO	119
20cdffa4 SO	120	if (!priv \|\| gdev->state != CCWGROUP_ONLINE)
293d984f PT	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,
3c09e264	134	sizeof(priv->channel[CTCM_WRITE]->prof));
293d984f PT	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	{
a68be015	151	int value, rc;
293d984f PT	152	struct ctcm_priv *priv = dev_get_drvdata(dev);
	153
	154	if (!priv)
	155	return -ENODEV;
652d77ba TR	156	rc = kstrtoint(buf, 0, &value);
652d77ba TR	157	if (rc \|\|
a68be015	158	!((value == CTCM_PROTO_S390) \|\|
293d984f PT	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
c4736d96	169	static const char *ctcm_type[] = {
0ca8cc6f UB	170	"not a channel",
	171	"CTC/A",
	172	"FICON channel",
	173	"ESCON channel",
	174	"unknown channel type",
	175	"unsupported channel type",
	176	};
	177
293d984f PT	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",
0ca8cc6f	188	ctcm_type[cgdev->cdev[0]->id.driver_info]);
293d984f PT	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,
20cdffa4	200	&dev_attr_stats.attr,
293d984f PT	201	NULL,
	202	};
	203
	204	static struct attribute_group ctcm_attr_group = {
	205	.attrs = ctcm_attr,
	206	};
20cdffa4 SO	207	const struct attribute_group *ctcm_attr_groups[] = {
	208	&ctcm_attr_group,
	209	NULL,
	210	};