blob: a43035d4bd70d6b4bca8947b9060de52c8d374e5 [file] [log] [blame]
Swen Schillig60221922008-07-02 10:56:38 +02001/*
2 * zfcp device driver
3 *
4 * sysfs attributes.
5 *
Christof Schmitt615f59e2010-02-17 11:18:56 +01006 * Copyright IBM Corporation 2008, 2010
Swen Schillig60221922008-07-02 10:56:38 +02007 */
8
Christof Schmittecf39d42008-12-25 13:39:53 +01009#define KMSG_COMPONENT "zfcp"
10#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
11
Swen Schillig60221922008-07-02 10:56:38 +020012#include "zfcp_ext.h"
13
14#define ZFCP_DEV_ATTR(_feat, _name, _mode, _show, _store) \
15struct device_attribute dev_attr_##_feat##_##_name = __ATTR(_name, _mode,\
16 _show, _store)
17#define ZFCP_DEFINE_ATTR(_feat_def, _feat, _name, _format, _value) \
18static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev, \
19 struct device_attribute *at,\
20 char *buf) \
21{ \
Christof Schmitt615f59e2010-02-17 11:18:56 +010022 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
Swen Schillig60221922008-07-02 10:56:38 +020023 \
24 return sprintf(buf, _format, _value); \
25} \
26static ZFCP_DEV_ATTR(_feat, _name, S_IRUGO, \
27 zfcp_sysfs_##_feat##_##_name##_show, NULL);
28
Swen Schilligde3dc572009-11-24 16:54:00 +010029#define ZFCP_DEFINE_A_ATTR(_name, _format, _value) \
30static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, \
31 struct device_attribute *at,\
32 char *buf) \
33{ \
34 struct ccw_device *cdev = to_ccwdev(dev); \
35 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); \
36 int i; \
37 \
38 if (!adapter) \
39 return -ENODEV; \
40 \
41 i = sprintf(buf, _format, _value); \
42 zfcp_ccw_adapter_put(adapter); \
43 return i; \
44} \
45static ZFCP_DEV_ATTR(adapter, _name, S_IRUGO, \
46 zfcp_sysfs_adapter_##_name##_show, NULL);
47
48ZFCP_DEFINE_A_ATTR(status, "0x%08x\n", atomic_read(&adapter->status));
49ZFCP_DEFINE_A_ATTR(peer_wwnn, "0x%016llx\n",
50 (unsigned long long) adapter->peer_wwnn);
51ZFCP_DEFINE_A_ATTR(peer_wwpn, "0x%016llx\n",
52 (unsigned long long) adapter->peer_wwpn);
53ZFCP_DEFINE_A_ATTR(peer_d_id, "0x%06x\n", adapter->peer_d_id);
54ZFCP_DEFINE_A_ATTR(card_version, "0x%04x\n", adapter->hydra_version);
55ZFCP_DEFINE_A_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version);
56ZFCP_DEFINE_A_ATTR(hardware_version, "0x%08x\n", adapter->hardware_version);
57ZFCP_DEFINE_A_ATTR(in_recovery, "%d\n", (atomic_read(&adapter->status) &
58 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
Swen Schillig60221922008-07-02 10:56:38 +020059
60ZFCP_DEFINE_ATTR(zfcp_port, port, status, "0x%08x\n",
61 atomic_read(&port->status));
62ZFCP_DEFINE_ATTR(zfcp_port, port, in_recovery, "%d\n",
63 (atomic_read(&port->status) &
64 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
65ZFCP_DEFINE_ATTR(zfcp_port, port, access_denied, "%d\n",
66 (atomic_read(&port->status) &
67 ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
68
69ZFCP_DEFINE_ATTR(zfcp_unit, unit, status, "0x%08x\n",
70 atomic_read(&unit->status));
71ZFCP_DEFINE_ATTR(zfcp_unit, unit, in_recovery, "%d\n",
72 (atomic_read(&unit->status) &
73 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
74ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_denied, "%d\n",
75 (atomic_read(&unit->status) &
76 ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
77ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_shared, "%d\n",
78 (atomic_read(&unit->status) &
79 ZFCP_STATUS_UNIT_SHARED) != 0);
80ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_readonly, "%d\n",
81 (atomic_read(&unit->status) &
82 ZFCP_STATUS_UNIT_READONLY) != 0);
83
84#define ZFCP_SYSFS_FAILED(_feat_def, _feat, _adapter, _mod_id, _reopen_id) \
85static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev, \
86 struct device_attribute *attr, \
87 char *buf) \
88{ \
Christof Schmitt615f59e2010-02-17 11:18:56 +010089 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
Swen Schillig60221922008-07-02 10:56:38 +020090 \
91 if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED) \
92 return sprintf(buf, "1\n"); \
93 else \
94 return sprintf(buf, "0\n"); \
95} \
96static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev, \
97 struct device_attribute *attr,\
98 const char *buf, size_t count)\
99{ \
Christof Schmitt615f59e2010-02-17 11:18:56 +0100100 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
Swen Schillig60221922008-07-02 10:56:38 +0200101 unsigned long val; \
102 int retval = 0; \
103 \
Christof Schmitt615f59e2010-02-17 11:18:56 +0100104 if (!(_feat && get_device(&_feat->dev))) \
Swen Schillig6b1833342009-11-24 16:54:05 +0100105 return -EBUSY; \
Swen Schillig60221922008-07-02 10:56:38 +0200106 \
107 if (strict_strtoul(buf, 0, &val) || val != 0) { \
108 retval = -EINVAL; \
109 goto out; \
110 } \
111 \
112 zfcp_erp_modify_##_feat##_status(_feat, _mod_id, NULL, \
113 ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);\
114 zfcp_erp_##_feat##_reopen(_feat, ZFCP_STATUS_COMMON_ERP_FAILED, \
115 _reopen_id, NULL); \
116 zfcp_erp_wait(_adapter); \
117out: \
Christof Schmitt615f59e2010-02-17 11:18:56 +0100118 put_device(&_feat->dev); \
Swen Schillig60221922008-07-02 10:56:38 +0200119 return retval ? retval : (ssize_t) count; \
120} \
121static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO, \
122 zfcp_sysfs_##_feat##_failed_show, \
123 zfcp_sysfs_##_feat##_failed_store);
124
Swen Schillig5ffd51a2009-03-02 13:09:04 +0100125ZFCP_SYSFS_FAILED(zfcp_port, port, port->adapter, "sypfai1", "sypfai2");
126ZFCP_SYSFS_FAILED(zfcp_unit, unit, unit->port->adapter, "syufai1", "syufai2");
Swen Schillig60221922008-07-02 10:56:38 +0200127
Swen Schilligde3dc572009-11-24 16:54:00 +0100128static ssize_t zfcp_sysfs_adapter_failed_show(struct device *dev,
129 struct device_attribute *attr,
130 char *buf)
131{
132 struct ccw_device *cdev = to_ccwdev(dev);
133 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
134 int i;
135
136 if (!adapter)
137 return -ENODEV;
138
139 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
140 i = sprintf(buf, "1\n");
141 else
142 i = sprintf(buf, "0\n");
143
144 zfcp_ccw_adapter_put(adapter);
145 return i;
146}
147
148static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
149 struct device_attribute *attr,
150 const char *buf, size_t count)
151{
152 struct ccw_device *cdev = to_ccwdev(dev);
153 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
154 unsigned long val;
155 int retval = 0;
156
157 if (!adapter)
158 return -ENODEV;
159
Swen Schilligde3dc572009-11-24 16:54:00 +0100160 if (strict_strtoul(buf, 0, &val) || val != 0) {
161 retval = -EINVAL;
162 goto out;
163 }
164
165 zfcp_erp_modify_adapter_status(adapter, "syafai1", NULL,
166 ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
167 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
168 "syafai2", NULL);
169 zfcp_erp_wait(adapter);
170out:
171 zfcp_ccw_adapter_put(adapter);
172 return retval ? retval : (ssize_t) count;
173}
174static ZFCP_DEV_ATTR(adapter, failed, S_IWUSR | S_IRUGO,
175 zfcp_sysfs_adapter_failed_show,
176 zfcp_sysfs_adapter_failed_store);
177
Swen Schillig60221922008-07-02 10:56:38 +0200178static ssize_t zfcp_sysfs_port_rescan_store(struct device *dev,
179 struct device_attribute *attr,
180 const char *buf, size_t count)
181{
Swen Schilligde3dc572009-11-24 16:54:00 +0100182 struct ccw_device *cdev = to_ccwdev(dev);
183 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
Swen Schillig60221922008-07-02 10:56:38 +0200184
Swen Schilligde3dc572009-11-24 16:54:00 +0100185 if (!adapter)
186 return -ENODEV;
187
Swen Schillig9eae07e2009-11-24 16:54:06 +0100188 /* sync the user-space- with the kernel-invocation of scan_work */
189 queue_work(adapter->work_queue, &adapter->scan_work);
190 flush_work(&adapter->scan_work);
Swen Schilligde3dc572009-11-24 16:54:00 +0100191 zfcp_ccw_adapter_put(adapter);
Swen Schillig6b1833342009-11-24 16:54:05 +0100192
Swen Schillig9eae07e2009-11-24 16:54:06 +0100193 return (ssize_t) count;
Swen Schillig60221922008-07-02 10:56:38 +0200194}
195static ZFCP_DEV_ATTR(adapter, port_rescan, S_IWUSR, NULL,
196 zfcp_sysfs_port_rescan_store);
197
198static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
199 struct device_attribute *attr,
200 const char *buf, size_t count)
201{
Swen Schilligde3dc572009-11-24 16:54:00 +0100202 struct ccw_device *cdev = to_ccwdev(dev);
203 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
Swen Schillig60221922008-07-02 10:56:38 +0200204 struct zfcp_port *port;
Swen Schillig7ba58c92008-10-01 12:42:18 +0200205 u64 wwpn;
Swen Schillig6b1833342009-11-24 16:54:05 +0100206 int retval = -EINVAL;
Swen Schillig60221922008-07-02 10:56:38 +0200207
Swen Schilligde3dc572009-11-24 16:54:00 +0100208 if (!adapter)
209 return -ENODEV;
210
Swen Schillig6b1833342009-11-24 16:54:05 +0100211 if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn))
Swen Schillig60221922008-07-02 10:56:38 +0200212 goto out;
Swen Schillig60221922008-07-02 10:56:38 +0200213
Swen Schillig60221922008-07-02 10:56:38 +0200214 port = zfcp_get_port_by_wwpn(adapter, wwpn);
Swen Schillig6b1833342009-11-24 16:54:05 +0100215 if (!port)
Swen Schillig60221922008-07-02 10:56:38 +0200216 goto out;
Swen Schillig6b1833342009-11-24 16:54:05 +0100217 else
218 retval = 0;
Swen Schilligf3450c72009-11-24 16:53:59 +0100219
220 write_lock_irq(&adapter->port_list_lock);
221 list_del(&port->list);
222 write_unlock_irq(&adapter->port_list_lock);
223
Christof Schmitt615f59e2010-02-17 11:18:56 +0100224 put_device(&port->dev);
Swen Schilligf3450c72009-11-24 16:53:59 +0100225
Swen Schillig5ffd51a2009-03-02 13:09:04 +0100226 zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
Christof Schmitt615f59e2010-02-17 11:18:56 +0100227 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
Swen Schillig60221922008-07-02 10:56:38 +0200228 out:
Swen Schilligde3dc572009-11-24 16:54:00 +0100229 zfcp_ccw_adapter_put(adapter);
Swen Schillig60221922008-07-02 10:56:38 +0200230 return retval ? retval : (ssize_t) count;
231}
232static ZFCP_DEV_ATTR(adapter, port_remove, S_IWUSR, NULL,
233 zfcp_sysfs_port_remove_store);
234
235static struct attribute *zfcp_adapter_attrs[] = {
236 &dev_attr_adapter_failed.attr,
237 &dev_attr_adapter_in_recovery.attr,
238 &dev_attr_adapter_port_remove.attr,
239 &dev_attr_adapter_port_rescan.attr,
240 &dev_attr_adapter_peer_wwnn.attr,
241 &dev_attr_adapter_peer_wwpn.attr,
242 &dev_attr_adapter_peer_d_id.attr,
243 &dev_attr_adapter_card_version.attr,
244 &dev_attr_adapter_lic_version.attr,
245 &dev_attr_adapter_status.attr,
246 &dev_attr_adapter_hardware_version.attr,
247 NULL
248};
249
250struct attribute_group zfcp_sysfs_adapter_attrs = {
251 .attrs = zfcp_adapter_attrs,
252};
253
254static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
255 struct device_attribute *attr,
256 const char *buf, size_t count)
257{
Christof Schmitt615f59e2010-02-17 11:18:56 +0100258 struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
Swen Schillig60221922008-07-02 10:56:38 +0200259 struct zfcp_unit *unit;
Swen Schillig7ba58c92008-10-01 12:42:18 +0200260 u64 fcp_lun;
Swen Schillig60221922008-07-02 10:56:38 +0200261 int retval = -EINVAL;
262
Christof Schmitt615f59e2010-02-17 11:18:56 +0100263 if (!(port && get_device(&port->dev)))
Swen Schillig6b1833342009-11-24 16:54:05 +0100264 return -EBUSY;
Swen Schillig60221922008-07-02 10:56:38 +0200265
Swen Schillig7ba58c92008-10-01 12:42:18 +0200266 if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
Swen Schillig60221922008-07-02 10:56:38 +0200267 goto out;
268
269 unit = zfcp_unit_enqueue(port, fcp_lun);
270 if (IS_ERR(unit))
271 goto out;
Swen Schillig6b1833342009-11-24 16:54:05 +0100272 else
273 retval = 0;
Swen Schillig60221922008-07-02 10:56:38 +0200274
Swen Schillig5ffd51a2009-03-02 13:09:04 +0100275 zfcp_erp_unit_reopen(unit, 0, "syuas_1", NULL);
Swen Schillig60221922008-07-02 10:56:38 +0200276 zfcp_erp_wait(unit->port->adapter);
Christof Schmitt9e820af2009-10-13 10:44:11 +0200277 flush_work(&unit->scsi_work);
Swen Schillig60221922008-07-02 10:56:38 +0200278out:
Christof Schmitt615f59e2010-02-17 11:18:56 +0100279 put_device(&port->dev);
Swen Schillig60221922008-07-02 10:56:38 +0200280 return retval ? retval : (ssize_t) count;
281}
282static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
283
284static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
285 struct device_attribute *attr,
286 const char *buf, size_t count)
287{
Christof Schmitt615f59e2010-02-17 11:18:56 +0100288 struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
Swen Schillig60221922008-07-02 10:56:38 +0200289 struct zfcp_unit *unit;
Swen Schillig7ba58c92008-10-01 12:42:18 +0200290 u64 fcp_lun;
Swen Schillig6b1833342009-11-24 16:54:05 +0100291 int retval = -EINVAL;
Swen Schillig60221922008-07-02 10:56:38 +0200292
Christof Schmitt615f59e2010-02-17 11:18:56 +0100293 if (!(port && get_device(&port->dev)))
Swen Schillig6b1833342009-11-24 16:54:05 +0100294 return -EBUSY;
Swen Schillig60221922008-07-02 10:56:38 +0200295
Swen Schillig6b1833342009-11-24 16:54:05 +0100296 if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
Swen Schillig60221922008-07-02 10:56:38 +0200297 goto out;
Swen Schillig60221922008-07-02 10:56:38 +0200298
Swen Schillig60221922008-07-02 10:56:38 +0200299 unit = zfcp_get_unit_by_lun(port, fcp_lun);
Swen Schillig6b1833342009-11-24 16:54:05 +0100300 if (!unit)
Swen Schillig60221922008-07-02 10:56:38 +0200301 goto out;
Swen Schillig6b1833342009-11-24 16:54:05 +0100302 else
303 retval = 0;
Swen Schillig60221922008-07-02 10:56:38 +0200304
Swen Schilligecf0c772009-11-24 16:53:58 +0100305 /* wait for possible timeout during SCSI probe */
306 flush_work(&unit->scsi_work);
307
Swen Schilligf3450c72009-11-24 16:53:59 +0100308 write_lock_irq(&port->unit_list_lock);
309 list_del(&unit->list);
310 write_unlock_irq(&port->unit_list_lock);
Swen Schilligecf0c772009-11-24 16:53:58 +0100311
Christof Schmitt615f59e2010-02-17 11:18:56 +0100312 put_device(&unit->dev);
Swen Schilligf3450c72009-11-24 16:53:59 +0100313
314 zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL);
Christof Schmitt615f59e2010-02-17 11:18:56 +0100315 zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
Swen Schillig60221922008-07-02 10:56:38 +0200316out:
Christof Schmitt615f59e2010-02-17 11:18:56 +0100317 put_device(&port->dev);
Swen Schillig60221922008-07-02 10:56:38 +0200318 return retval ? retval : (ssize_t) count;
319}
320static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
321
Swen Schillig5ab944f2008-10-01 12:42:17 +0200322static struct attribute *zfcp_port_attrs[] = {
Swen Schillig60221922008-07-02 10:56:38 +0200323 &dev_attr_unit_add.attr,
324 &dev_attr_unit_remove.attr,
325 &dev_attr_port_failed.attr,
326 &dev_attr_port_in_recovery.attr,
327 &dev_attr_port_status.attr,
328 &dev_attr_port_access_denied.attr,
329 NULL
330};
331
332/**
333 * zfcp_sysfs_port_attrs - sysfs attributes for all other ports
334 */
335struct attribute_group zfcp_sysfs_port_attrs = {
Swen Schillig5ab944f2008-10-01 12:42:17 +0200336 .attrs = zfcp_port_attrs,
Swen Schillig60221922008-07-02 10:56:38 +0200337};
338
339static struct attribute *zfcp_unit_attrs[] = {
340 &dev_attr_unit_failed.attr,
341 &dev_attr_unit_in_recovery.attr,
342 &dev_attr_unit_status.attr,
343 &dev_attr_unit_access_denied.attr,
344 &dev_attr_unit_access_shared.attr,
345 &dev_attr_unit_access_readonly.attr,
346 NULL
347};
348
349struct attribute_group zfcp_sysfs_unit_attrs = {
350 .attrs = zfcp_unit_attrs,
351};
352
353#define ZFCP_DEFINE_LATENCY_ATTR(_name) \
354static ssize_t \
355zfcp_sysfs_unit_##_name##_latency_show(struct device *dev, \
356 struct device_attribute *attr, \
357 char *buf) { \
358 struct scsi_device *sdev = to_scsi_device(dev); \
359 struct zfcp_unit *unit = sdev->hostdata; \
360 struct zfcp_latencies *lat = &unit->latencies; \
361 struct zfcp_adapter *adapter = unit->port->adapter; \
Swen Schillig60221922008-07-02 10:56:38 +0200362 unsigned long long fsum, fmin, fmax, csum, cmin, cmax, cc; \
363 \
Christof Schmitt49f0f012009-03-02 13:08:57 +0100364 spin_lock_bh(&lat->lock); \
Swen Schillig60221922008-07-02 10:56:38 +0200365 fsum = lat->_name.fabric.sum * adapter->timer_ticks; \
366 fmin = lat->_name.fabric.min * adapter->timer_ticks; \
367 fmax = lat->_name.fabric.max * adapter->timer_ticks; \
368 csum = lat->_name.channel.sum * adapter->timer_ticks; \
369 cmin = lat->_name.channel.min * adapter->timer_ticks; \
370 cmax = lat->_name.channel.max * adapter->timer_ticks; \
371 cc = lat->_name.counter; \
Christof Schmitt49f0f012009-03-02 13:08:57 +0100372 spin_unlock_bh(&lat->lock); \
Swen Schillig60221922008-07-02 10:56:38 +0200373 \
374 do_div(fsum, 1000); \
375 do_div(fmin, 1000); \
376 do_div(fmax, 1000); \
377 do_div(csum, 1000); \
378 do_div(cmin, 1000); \
379 do_div(cmax, 1000); \
380 \
381 return sprintf(buf, "%llu %llu %llu %llu %llu %llu %llu\n", \
382 fmin, fmax, fsum, cmin, cmax, csum, cc); \
383} \
384static ssize_t \
385zfcp_sysfs_unit_##_name##_latency_store(struct device *dev, \
386 struct device_attribute *attr, \
387 const char *buf, size_t count) \
388{ \
389 struct scsi_device *sdev = to_scsi_device(dev); \
390 struct zfcp_unit *unit = sdev->hostdata; \
391 struct zfcp_latencies *lat = &unit->latencies; \
392 unsigned long flags; \
393 \
394 spin_lock_irqsave(&lat->lock, flags); \
395 lat->_name.fabric.sum = 0; \
396 lat->_name.fabric.min = 0xFFFFFFFF; \
397 lat->_name.fabric.max = 0; \
398 lat->_name.channel.sum = 0; \
399 lat->_name.channel.min = 0xFFFFFFFF; \
400 lat->_name.channel.max = 0; \
401 lat->_name.counter = 0; \
402 spin_unlock_irqrestore(&lat->lock, flags); \
403 \
404 return (ssize_t) count; \
405} \
406static DEVICE_ATTR(_name##_latency, S_IWUSR | S_IRUGO, \
407 zfcp_sysfs_unit_##_name##_latency_show, \
408 zfcp_sysfs_unit_##_name##_latency_store);
409
410ZFCP_DEFINE_LATENCY_ATTR(read);
411ZFCP_DEFINE_LATENCY_ATTR(write);
412ZFCP_DEFINE_LATENCY_ATTR(cmd);
413
414#define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
415static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, \
416 struct device_attribute *attr,\
417 char *buf) \
418{ \
419 struct scsi_device *sdev = to_scsi_device(dev); \
420 struct zfcp_unit *unit = sdev->hostdata; \
421 \
422 return sprintf(buf, _format, _value); \
423} \
424static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
425
426ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
Cornelia Huckb9d3aed2008-10-10 21:33:11 +0200427 dev_name(&unit->port->adapter->ccw_device->dev));
Swen Schillig7ba58c92008-10-01 12:42:18 +0200428ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
429 (unsigned long long) unit->port->wwpn);
430ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n",
431 (unsigned long long) unit->fcp_lun);
Swen Schillig60221922008-07-02 10:56:38 +0200432
433struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
434 &dev_attr_fcp_lun,
435 &dev_attr_wwpn,
436 &dev_attr_hba_id,
437 &dev_attr_read_latency,
438 &dev_attr_write_latency,
439 &dev_attr_cmd_latency,
440 NULL
441};
442
443static ssize_t zfcp_sysfs_adapter_util_show(struct device *dev,
444 struct device_attribute *attr,
445 char *buf)
446{
447 struct Scsi_Host *scsi_host = dev_to_shost(dev);
448 struct fsf_qtcb_bottom_port *qtcb_port;
449 struct zfcp_adapter *adapter;
450 int retval;
451
452 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
453 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
454 return -EOPNOTSUPP;
455
456 qtcb_port = kzalloc(sizeof(struct fsf_qtcb_bottom_port), GFP_KERNEL);
457 if (!qtcb_port)
458 return -ENOMEM;
459
Swen Schillig564e1c82009-08-18 15:43:19 +0200460 retval = zfcp_fsf_exchange_port_data_sync(adapter->qdio, qtcb_port);
Swen Schillig60221922008-07-02 10:56:38 +0200461 if (!retval)
462 retval = sprintf(buf, "%u %u %u\n", qtcb_port->cp_util,
463 qtcb_port->cb_util, qtcb_port->a_util);
464 kfree(qtcb_port);
465 return retval;
466}
467static DEVICE_ATTR(utilization, S_IRUGO, zfcp_sysfs_adapter_util_show, NULL);
468
469static int zfcp_sysfs_adapter_ex_config(struct device *dev,
470 struct fsf_statistics_info *stat_inf)
471{
472 struct Scsi_Host *scsi_host = dev_to_shost(dev);
473 struct fsf_qtcb_bottom_config *qtcb_config;
474 struct zfcp_adapter *adapter;
475 int retval;
476
477 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
478 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
479 return -EOPNOTSUPP;
480
481 qtcb_config = kzalloc(sizeof(struct fsf_qtcb_bottom_config),
482 GFP_KERNEL);
483 if (!qtcb_config)
484 return -ENOMEM;
485
Swen Schillig564e1c82009-08-18 15:43:19 +0200486 retval = zfcp_fsf_exchange_config_data_sync(adapter->qdio, qtcb_config);
Swen Schillig60221922008-07-02 10:56:38 +0200487 if (!retval)
488 *stat_inf = qtcb_config->stat_info;
489
490 kfree(qtcb_config);
491 return retval;
492}
493
494#define ZFCP_SHOST_ATTR(_name, _format, _arg...) \
495static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, \
496 struct device_attribute *attr,\
497 char *buf) \
498{ \
499 struct fsf_statistics_info stat_info; \
500 int retval; \
501 \
502 retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info); \
503 if (retval) \
504 return retval; \
505 \
506 return sprintf(buf, _format, ## _arg); \
507} \
508static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_adapter_##_name##_show, NULL);
509
510ZFCP_SHOST_ATTR(requests, "%llu %llu %llu\n",
511 (unsigned long long) stat_info.input_req,
512 (unsigned long long) stat_info.output_req,
513 (unsigned long long) stat_info.control_req);
514
515ZFCP_SHOST_ATTR(megabytes, "%llu %llu\n",
516 (unsigned long long) stat_info.input_mb,
517 (unsigned long long) stat_info.output_mb);
518
519ZFCP_SHOST_ATTR(seconds_active, "%llu\n",
520 (unsigned long long) stat_info.seconds_act);
521
Stefan Raspl2450d3e2008-10-01 12:42:14 +0200522static ssize_t zfcp_sysfs_adapter_q_full_show(struct device *dev,
523 struct device_attribute *attr,
524 char *buf)
525{
526 struct Scsi_Host *scsi_host = class_to_shost(dev);
Swen Schillig564e1c82009-08-18 15:43:19 +0200527 struct zfcp_qdio *qdio =
528 ((struct zfcp_adapter *) scsi_host->hostdata[0])->qdio;
Christof Schmittacf7b862009-07-13 15:06:03 +0200529 u64 util;
530
Swen Schillig564e1c82009-08-18 15:43:19 +0200531 spin_lock_bh(&qdio->stat_lock);
532 util = qdio->req_q_util;
533 spin_unlock_bh(&qdio->stat_lock);
Stefan Raspl2450d3e2008-10-01 12:42:14 +0200534
Swen Schillig564e1c82009-08-18 15:43:19 +0200535 return sprintf(buf, "%d %llu\n", atomic_read(&qdio->req_q_full),
Christof Schmittacf7b862009-07-13 15:06:03 +0200536 (unsigned long long)util);
Stefan Raspl2450d3e2008-10-01 12:42:14 +0200537}
538static DEVICE_ATTR(queue_full, S_IRUGO, zfcp_sysfs_adapter_q_full_show, NULL);
539
Swen Schillig60221922008-07-02 10:56:38 +0200540struct device_attribute *zfcp_sysfs_shost_attrs[] = {
541 &dev_attr_utilization,
542 &dev_attr_requests,
543 &dev_attr_megabytes,
544 &dev_attr_seconds_active,
Stefan Raspl2450d3e2008-10-01 12:42:14 +0200545 &dev_attr_queue_full,
Swen Schillig60221922008-07-02 10:56:38 +0200546 NULL
547};