Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 60221920 authored by Swen Schillig's avatar Swen Schillig Committed by James Bottomley
Browse files

[SCSI] zfcp: consolidate sysfs things into one file. 



zfcp was using three files to deal with sysfs representation
for adapters, ports and units. The consolidation into one file
prevents code-duplication and eases maintainability.

Signed-off-by: default avatarSwen Schillig <swen@vnet.ibm.com>
Signed-off-by: default avatarChristof Schmitt <christof.schmitt@de.ibm.com>
Signed-off-by: default avatarJames Bottomley <James.Bottomley@HansenPartnership.com>
parent 317e6b65

drivers/s390/scsi/Makefile

+1 −2
Original line number Diff line number Diff line
@@ -3,7 +3,6 @@ 
#



zfcp-objs := zfcp_aux.o zfcp_ccw.o zfcp_scsi.o zfcp_erp.o zfcp_qdio.o \

	     zfcp_fsf.o zfcp_dbf.o zfcp_sysfs_adapter.o zfcp_sysfs_port.o \

	     zfcp_sysfs_unit.o zfcp_fc.o zfcp_cfdc.o

	     zfcp_fsf.o zfcp_dbf.o zfcp_sysfs.o zfcp_fc.o zfcp_cfdc.o



obj-$(CONFIG_ZFCP) += zfcp.o

drivers/s390/scsi/zfcp_aux.c

+34 −8
Original line number Diff line number Diff line
@@ -262,6 +262,11 @@ struct zfcp_port *zfcp_get_port_by_wwpn(struct zfcp_adapter *adapter, 
	return NULL;

}



static void zfcp_sysfs_unit_release(struct device *dev)

{

	kfree(container_of(dev, struct zfcp_unit, sysfs_device));

}



/**

 * zfcp_unit_enqueue - enqueue unit to unit list of a port.

 * @port: pointer to port where unit is added
@@ -311,7 +316,8 @@ struct zfcp_unit *zfcp_unit_enqueue(struct zfcp_port *port, fcp_lun_t fcp_lun) 
	if (device_register(&unit->sysfs_device))

		goto err_out_free;



	if (zfcp_sysfs_unit_create_files(&unit->sysfs_device)) {

	if (sysfs_create_group(&unit->sysfs_device.kobj,

			       &zfcp_sysfs_unit_attrs)) {

		device_unregister(&unit->sysfs_device);

		return ERR_PTR(-EIO);

	}
@@ -351,7 +357,7 @@ void zfcp_unit_dequeue(struct zfcp_unit *unit) 
	write_unlock_irq(&zfcp_data.config_lock);

	unit->port->units--;

	zfcp_port_put(unit->port);

	zfcp_sysfs_unit_remove_files(&unit->sysfs_device);

	sysfs_remove_group(&unit->sysfs_device.kobj, &zfcp_sysfs_unit_attrs);

	device_unregister(&unit->sysfs_device);

}
@@ -527,7 +533,8 @@ int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 


	dev_set_drvdata(&ccw_device->dev, adapter);



	if (zfcp_sysfs_adapter_create_files(&ccw_device->dev))

	if (sysfs_create_group(&ccw_device->dev.kobj,

			       &zfcp_sysfs_adapter_attrs))

		goto sysfs_failed;



	adapter->generic_services.parent = &adapter->ccw_device->dev;
@@ -550,7 +557,8 @@ int zfcp_adapter_enqueue(struct ccw_device *ccw_device) 
	return 0;



generic_services_failed:

	zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);

	sysfs_remove_group(&ccw_device->dev.kobj,

			   &zfcp_sysfs_adapter_attrs);

sysfs_failed:

	zfcp_adapter_debug_unregister(adapter);

debug_register_failed:
@@ -578,7 +586,8 @@ void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 
	cancel_work_sync(&adapter->stat_work);

	zfcp_adapter_scsi_unregister(adapter);

	device_unregister(&adapter->generic_services);

	zfcp_sysfs_adapter_remove_files(&adapter->ccw_device->dev);

	sysfs_remove_group(&adapter->ccw_device->dev.kobj,

			   &zfcp_sysfs_adapter_attrs);

	dev_set_drvdata(&adapter->ccw_device->dev, NULL);

	/* sanity check: no pending FSF requests */

	spin_lock_irqsave(&adapter->req_list_lock, flags);
@@ -606,6 +615,11 @@ void zfcp_adapter_dequeue(struct zfcp_adapter *adapter) 
	kfree(adapter);

}



static void zfcp_sysfs_port_release(struct device *dev)

{

	kfree(container_of(dev, struct zfcp_port, sysfs_device));

}



/**

 * zfcp_port_enqueue - enqueue port to port list of adapter

 * @adapter: adapter where remote port is added
@@ -623,6 +637,7 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
				     u32 status, u32 d_id)

{

	struct zfcp_port *port;

	int retval;

	char *bus_id;



	port = kzalloc(sizeof(struct zfcp_port), GFP_KERNEL);
@@ -685,7 +700,14 @@ struct zfcp_port *zfcp_port_enqueue(struct zfcp_adapter *adapter, wwn_t wwpn, 
	if (device_register(&port->sysfs_device))

		goto err_out_free;



	if (zfcp_sysfs_port_create_files(&port->sysfs_device, status)) {

	if (status & ZFCP_STATUS_PORT_WKA)

		retval = sysfs_create_group(&port->sysfs_device.kobj,

					    &zfcp_sysfs_ns_port_attrs);

	else

		retval = sysfs_create_group(&port->sysfs_device.kobj,

					    &zfcp_sysfs_port_attrs);



	if (retval) {

		device_unregister(&port->sysfs_device);

		goto err_out;

	}
@@ -727,8 +749,12 @@ void zfcp_port_dequeue(struct zfcp_port *port) 
		fc_remote_port_delete(port->rport);

	port->rport = NULL;

	zfcp_adapter_put(port->adapter);

	zfcp_sysfs_port_remove_files(&port->sysfs_device,

				     atomic_read(&port->status));

	if (atomic_read(&port->status) & ZFCP_STATUS_PORT_WKA)

		sysfs_remove_group(&port->sysfs_device.kobj,

				   &zfcp_sysfs_ns_port_attrs);

	else

		sysfs_remove_group(&port->sysfs_device.kobj,

				   &zfcp_sysfs_port_attrs);

	device_unregister(&port->sysfs_device);

}

drivers/s390/scsi/zfcp_def.h

+0 −9
Original line number Diff line number Diff line
@@ -627,11 +627,6 @@ struct zfcp_adapter { 
	struct work_struct	scan_work;

};



/*

 * the struct device sysfs_device must be at the beginning of this structure.

 * pointer to struct device is used to free port structure in release function

 * of the device. don't change!

 */

struct zfcp_port {

	struct device          sysfs_device;   /* sysfs device */

	struct fc_rport        *rport;         /* rport of fc transport class */
@@ -655,10 +650,6 @@ struct zfcp_port { 
	u32                    supported_classes;

};



/* the struct device sysfs_device must be at the beginning of this structure.

 * pointer to struct device is used to free unit structure in release function

 * of the device. don't change!

 */

struct zfcp_unit {

	struct device          sysfs_device;   /* sysfs device */

	struct list_head       list;	       /* list of logical units */

drivers/s390/scsi/zfcp_ext.h

+7 −9
Original line number Diff line number Diff line
@@ -13,15 +13,13 @@ 


extern struct zfcp_data zfcp_data;



/******************************** SYSFS  *************************************/

extern int  zfcp_sysfs_adapter_create_files(struct device *);

extern void zfcp_sysfs_adapter_remove_files(struct device *);

extern int  zfcp_sysfs_port_create_files(struct device *, u32);

extern void zfcp_sysfs_port_remove_files(struct device *, u32);

extern int  zfcp_sysfs_unit_create_files(struct device *);

extern void zfcp_sysfs_unit_remove_files(struct device *);

extern void zfcp_sysfs_port_release(struct device *);

extern void zfcp_sysfs_unit_release(struct device *);

/* zfcp_sysfs.c */

extern struct attribute_group zfcp_sysfs_unit_attrs;

extern struct attribute_group zfcp_sysfs_adapter_attrs;

extern struct attribute_group zfcp_sysfs_ns_port_attrs;

extern struct attribute_group zfcp_sysfs_port_attrs;

extern struct device_attribute *zfcp_sysfs_sdev_attrs[];

extern struct device_attribute *zfcp_sysfs_shost_attrs[];



/**************************** CONFIGURATION  *********************************/

extern struct zfcp_unit *zfcp_get_unit_by_lun(struct zfcp_port *, fcp_lun_t);

drivers/s390/scsi/zfcp_scsi.c

+1 −205
Original line number Diff line number Diff line
@@ -520,209 +520,6 @@ struct fc_function_template zfcp_transport_functions = { 
	.disable_target_scan = 1,

};



#define ZFCP_DEFINE_LATENCY_ATTR(_name) 				\

static ssize_t								\

zfcp_sysfs_unit_##_name##_latency_show(struct device *dev,		\

				       struct device_attribute *attr,	\

				       char *buf) {			\

	struct scsi_device *sdev = to_scsi_device(dev);			\

	struct zfcp_unit *unit = sdev->hostdata;			\

	struct zfcp_latencies *lat = &unit->latencies;			\

	struct zfcp_adapter *adapter = unit->port->adapter;		\

	unsigned long flags;						\

	unsigned long long fsum, fmin, fmax, csum, cmin, cmax, cc;	\

									\

	spin_lock_irqsave(&lat->lock, flags);				\

	fsum = lat->_name.fabric.sum * adapter->timer_ticks;		\

	fmin = lat->_name.fabric.min * adapter->timer_ticks;		\

	fmax = lat->_name.fabric.max * adapter->timer_ticks;		\

	csum = lat->_name.channel.sum * adapter->timer_ticks;		\

	cmin = lat->_name.channel.min * adapter->timer_ticks;		\

	cmax = lat->_name.channel.max * adapter->timer_ticks;		\

	cc  = lat->_name.counter;					\

	spin_unlock_irqrestore(&lat->lock, flags);			\

									\

	do_div(fsum, 1000);						\

	do_div(fmin, 1000);						\

	do_div(fmax, 1000);						\

	do_div(csum, 1000);						\

	do_div(cmin, 1000);						\

	do_div(cmax, 1000);						\

									\

	return sprintf(buf, "%llu %llu %llu %llu %llu %llu %llu\n",	\

		       fmin, fmax, fsum, cmin, cmax, csum, cc); 	\

}									\

static ssize_t								\

zfcp_sysfs_unit_##_name##_latency_store(struct device *dev,		\

					struct device_attribute *attr,	\

					const char *buf, size_t count)	\

{									\

	struct scsi_device *sdev = to_scsi_device(dev);			\

	struct zfcp_unit *unit = sdev->hostdata;			\

	struct zfcp_latencies *lat = &unit->latencies;			\

	unsigned long flags;						\

									\

	spin_lock_irqsave(&lat->lock, flags);				\

	lat->_name.fabric.sum = 0;					\

	lat->_name.fabric.min = 0xFFFFFFFF;				\

	lat->_name.fabric.max = 0;					\

	lat->_name.channel.sum = 0;					\

	lat->_name.channel.min = 0xFFFFFFFF;				\

	lat->_name.channel.max = 0;					\

	lat->_name.counter = 0;						\

	spin_unlock_irqrestore(&lat->lock, flags);			\

									\

	return (ssize_t) count;						\

}									\

static DEVICE_ATTR(_name##_latency, S_IWUSR | S_IRUGO,			\

		   zfcp_sysfs_unit_##_name##_latency_show,		\

		   zfcp_sysfs_unit_##_name##_latency_store);



ZFCP_DEFINE_LATENCY_ATTR(read);

ZFCP_DEFINE_LATENCY_ATTR(write);

ZFCP_DEFINE_LATENCY_ATTR(cmd);



#define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value)                    \

static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, struct device_attribute *attr,        \

                                              char *buf)                 \

{                                                                        \

        struct scsi_device *sdev;                                        \

        struct zfcp_unit *unit;                                          \

                                                                         \

        sdev = to_scsi_device(dev);                                      \

        unit = sdev->hostdata;                                           \

        return sprintf(buf, _format, _value);                            \

}                                                                        \

                                                                         \

static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);



ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",

	unit->port->adapter->ccw_device->dev.bus_id);

ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n", unit->port->wwpn);

ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n", unit->fcp_lun);



static struct device_attribute *zfcp_sysfs_sdev_attrs[] = {

	&dev_attr_fcp_lun,

	&dev_attr_wwpn,

	&dev_attr_hba_id,

	&dev_attr_read_latency,

	&dev_attr_write_latency,

	&dev_attr_cmd_latency,

	NULL

};



static ssize_t zfcp_sysfs_adapter_util_show(struct device *dev,

					    struct device_attribute *attr,

					    char *buf)

{

	struct Scsi_Host *scsi_host = dev_to_shost(dev);

	struct fsf_qtcb_bottom_port *qtcb_port;

	struct zfcp_adapter *adapter;

	int retval;



	adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];

	if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))

		return -EOPNOTSUPP;



	qtcb_port = kzalloc(sizeof(struct fsf_qtcb_bottom_port), GFP_KERNEL);

	if (!qtcb_port)

		return -ENOMEM;



	retval = zfcp_fsf_exchange_port_data_sync(adapter, qtcb_port);

	if (!retval)

		retval = sprintf(buf, "%u %u %u\n", qtcb_port->cp_util,

				 qtcb_port->cb_util, qtcb_port->a_util);

	kfree(qtcb_port);

	return retval;

}



static int zfcp_sysfs_adapter_ex_config(struct device *dev,

					struct fsf_statistics_info *stat_inf)

{

	struct Scsi_Host *scsi_host = dev_to_shost(dev);

	struct fsf_qtcb_bottom_config *qtcb_config;

	struct zfcp_adapter *adapter;

	int retval;



	adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];

	if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))

		return -EOPNOTSUPP;



	qtcb_config = kzalloc(sizeof(struct fsf_qtcb_bottom_config),

			      GFP_KERNEL);

	if (!qtcb_config)

		return -ENOMEM;



	retval = zfcp_fsf_exchange_config_data_sync(adapter, qtcb_config);

	if (!retval)

		*stat_inf = qtcb_config->stat_info;



	kfree(qtcb_config);

	return retval;

}



static ssize_t zfcp_sysfs_adapter_request_show(struct device *dev,

					       struct device_attribute *attr,

					       char *buf)

{

	struct fsf_statistics_info stat_info;

	int retval;



	retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);

	if (retval)

		return retval;



	return sprintf(buf, "%llu %llu %llu\n",

		       (unsigned long long) stat_info.input_req,

		       (unsigned long long) stat_info.output_req,

		       (unsigned long long) stat_info.control_req);

}



static ssize_t zfcp_sysfs_adapter_mb_show(struct device *dev,

					  struct device_attribute *attr,

					  char *buf)

{

	struct fsf_statistics_info stat_info;

	int retval;



	retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);

	if (retval)

		return retval;



	return sprintf(buf, "%llu %llu\n",

		       (unsigned long long) stat_info.input_mb,

		       (unsigned long long) stat_info.output_mb);

}



static ssize_t zfcp_sysfs_adapter_sec_active_show(struct device *dev,

						  struct device_attribute *attr,

						  char *buf)

{

	struct fsf_statistics_info stat_info;

	int retval;



	retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info);

	if (retval)

		return retval;



	return sprintf(buf, "%llu\n",

		       (unsigned long long) stat_info.seconds_act);

}



static DEVICE_ATTR(utilization, S_IRUGO, zfcp_sysfs_adapter_util_show, NULL);

static DEVICE_ATTR(requests, S_IRUGO, zfcp_sysfs_adapter_request_show, NULL);

static DEVICE_ATTR(megabytes, S_IRUGO, zfcp_sysfs_adapter_mb_show, NULL);

static DEVICE_ATTR(seconds_active, S_IRUGO,

		   zfcp_sysfs_adapter_sec_active_show, NULL);



static struct device_attribute *zfcp_a_stats_attrs[] = {

	&dev_attr_utilization,

	&dev_attr_requests,

	&dev_attr_megabytes,

	&dev_attr_seconds_active,

	NULL

};



struct zfcp_data zfcp_data = {

	.scsi_host_template = {

		.name			 = "zfcp",
@@ -743,7 +540,6 @@ struct zfcp_data zfcp_data = { 
		.use_clustering		 = 1,

		.sdev_attrs		 = zfcp_sysfs_sdev_attrs,

		.max_sectors		 = (ZFCP_MAX_SBALES_PER_REQ * 8),

		.shost_attrs		 = zfcp_a_stats_attrs,

		.shost_attrs		 = zfcp_sysfs_shost_attrs,

	},

};