6 * Copyright IBM Corporation 2008, 2010
9 #define KMSG_COMPONENT "zfcp"
10 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
12 #include <linux/slab.h>
15 #define ZFCP_DEV_ATTR(_feat, _name, _mode, _show, _store) \
16 struct device_attribute dev_attr_##_feat##_##_name = __ATTR(_name, _mode,\
18 #define ZFCP_DEFINE_ATTR(_feat_def, _feat, _name, _format, _value) \
19 static ssize_t zfcp_sysfs_##_feat##_##_name##_show(struct device *dev, \
20 struct device_attribute *at,\
23 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
25 return sprintf(buf, _format, _value); \
27 static ZFCP_DEV_ATTR(_feat, _name, S_IRUGO, \
28 zfcp_sysfs_##_feat##_##_name##_show, NULL);
30 #define ZFCP_DEFINE_A_ATTR(_name, _format, _value) \
31 static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, \
32 struct device_attribute *at,\
35 struct ccw_device *cdev = to_ccwdev(dev); \
36 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev); \
42 i = sprintf(buf, _format, _value); \
43 zfcp_ccw_adapter_put(adapter); \
46 static ZFCP_DEV_ATTR(adapter, _name, S_IRUGO, \
47 zfcp_sysfs_adapter_##_name##_show, NULL);
49 ZFCP_DEFINE_A_ATTR(status, "0x%08x\n", atomic_read(&adapter->status));
50 ZFCP_DEFINE_A_ATTR(peer_wwnn, "0x%016llx\n",
51 (unsigned long long) adapter->peer_wwnn);
52 ZFCP_DEFINE_A_ATTR(peer_wwpn, "0x%016llx\n",
53 (unsigned long long) adapter->peer_wwpn);
54 ZFCP_DEFINE_A_ATTR(peer_d_id, "0x%06x\n", adapter->peer_d_id);
55 ZFCP_DEFINE_A_ATTR(card_version, "0x%04x\n", adapter->hydra_version);
56 ZFCP_DEFINE_A_ATTR(lic_version, "0x%08x\n", adapter->fsf_lic_version);
57 ZFCP_DEFINE_A_ATTR(hardware_version, "0x%08x\n", adapter->hardware_version);
58 ZFCP_DEFINE_A_ATTR(in_recovery, "%d\n", (atomic_read(&adapter->status) &
59 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
61 ZFCP_DEFINE_ATTR(zfcp_port, port, status, "0x%08x\n",
62 atomic_read(&port->status));
63 ZFCP_DEFINE_ATTR(zfcp_port, port, in_recovery, "%d\n",
64 (atomic_read(&port->status) &
65 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
66 ZFCP_DEFINE_ATTR(zfcp_port, port, access_denied, "%d\n",
67 (atomic_read(&port->status) &
68 ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
70 ZFCP_DEFINE_ATTR(zfcp_unit, unit, status, "0x%08x\n",
71 atomic_read(&unit->status));
72 ZFCP_DEFINE_ATTR(zfcp_unit, unit, in_recovery, "%d\n",
73 (atomic_read(&unit->status) &
74 ZFCP_STATUS_COMMON_ERP_INUSE) != 0);
75 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_denied, "%d\n",
76 (atomic_read(&unit->status) &
77 ZFCP_STATUS_COMMON_ACCESS_DENIED) != 0);
78 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_shared, "%d\n",
79 (atomic_read(&unit->status) &
80 ZFCP_STATUS_UNIT_SHARED) != 0);
81 ZFCP_DEFINE_ATTR(zfcp_unit, unit, access_readonly, "%d\n",
82 (atomic_read(&unit->status) &
83 ZFCP_STATUS_UNIT_READONLY) != 0);
85 #define ZFCP_SYSFS_FAILED(_feat_def, _feat, _adapter, _mod_id, _reopen_id) \
86 static ssize_t zfcp_sysfs_##_feat##_failed_show(struct device *dev, \
87 struct device_attribute *attr, \
90 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
92 if (atomic_read(&_feat->status) & ZFCP_STATUS_COMMON_ERP_FAILED) \
93 return sprintf(buf, "1\n"); \
95 return sprintf(buf, "0\n"); \
97 static ssize_t zfcp_sysfs_##_feat##_failed_store(struct device *dev, \
98 struct device_attribute *attr,\
99 const char *buf, size_t count)\
101 struct _feat_def *_feat = container_of(dev, struct _feat_def, dev); \
105 if (!(_feat && get_device(&_feat->dev))) \
108 if (strict_strtoul(buf, 0, &val) || val != 0) { \
113 zfcp_erp_modify_##_feat##_status(_feat, _mod_id, NULL, \
114 ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);\
115 zfcp_erp_##_feat##_reopen(_feat, ZFCP_STATUS_COMMON_ERP_FAILED, \
117 zfcp_erp_wait(_adapter); \
119 put_device(&_feat->dev); \
120 return retval ? retval : (ssize_t) count; \
122 static ZFCP_DEV_ATTR(_feat, failed, S_IWUSR | S_IRUGO, \
123 zfcp_sysfs_##_feat##_failed_show, \
124 zfcp_sysfs_##_feat##_failed_store);
126 ZFCP_SYSFS_FAILED(zfcp_port, port, port->adapter, "sypfai1", "sypfai2");
127 ZFCP_SYSFS_FAILED(zfcp_unit, unit, unit->port->adapter, "syufai1", "syufai2");
129 static ssize_t zfcp_sysfs_adapter_failed_show(struct device *dev,
130 struct device_attribute *attr,
133 struct ccw_device *cdev = to_ccwdev(dev);
134 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
140 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
141 i = sprintf(buf, "1\n");
143 i = sprintf(buf, "0\n");
145 zfcp_ccw_adapter_put(adapter);
149 static ssize_t zfcp_sysfs_adapter_failed_store(struct device *dev,
150 struct device_attribute *attr,
151 const char *buf, size_t count)
153 struct ccw_device *cdev = to_ccwdev(dev);
154 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
161 if (strict_strtoul(buf, 0, &val) || val != 0) {
166 zfcp_erp_modify_adapter_status(adapter, "syafai1", NULL,
167 ZFCP_STATUS_COMMON_RUNNING, ZFCP_SET);
168 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED,
170 zfcp_erp_wait(adapter);
172 zfcp_ccw_adapter_put(adapter);
173 return retval ? retval : (ssize_t) count;
175 static ZFCP_DEV_ATTR(adapter, failed, S_IWUSR | S_IRUGO,
176 zfcp_sysfs_adapter_failed_show,
177 zfcp_sysfs_adapter_failed_store);
179 static ssize_t zfcp_sysfs_port_rescan_store(struct device *dev,
180 struct device_attribute *attr,
181 const char *buf, size_t count)
183 struct ccw_device *cdev = to_ccwdev(dev);
184 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
189 /* sync the user-space- with the kernel-invocation of scan_work */
190 queue_work(adapter->work_queue, &adapter->scan_work);
191 flush_work(&adapter->scan_work);
192 zfcp_ccw_adapter_put(adapter);
194 return (ssize_t) count;
196 static ZFCP_DEV_ATTR(adapter, port_rescan, S_IWUSR, NULL,
197 zfcp_sysfs_port_rescan_store);
199 static ssize_t zfcp_sysfs_port_remove_store(struct device *dev,
200 struct device_attribute *attr,
201 const char *buf, size_t count)
203 struct ccw_device *cdev = to_ccwdev(dev);
204 struct zfcp_adapter *adapter = zfcp_ccw_adapter_by_cdev(cdev);
205 struct zfcp_port *port;
207 int retval = -EINVAL;
212 if (strict_strtoull(buf, 0, (unsigned long long *) &wwpn))
215 port = zfcp_get_port_by_wwpn(adapter, wwpn);
221 write_lock_irq(&adapter->port_list_lock);
222 list_del(&port->list);
223 write_unlock_irq(&adapter->port_list_lock);
225 put_device(&port->dev);
227 zfcp_erp_port_shutdown(port, 0, "syprs_1", NULL);
228 zfcp_device_unregister(&port->dev, &zfcp_sysfs_port_attrs);
230 zfcp_ccw_adapter_put(adapter);
231 return retval ? retval : (ssize_t) count;
233 static ZFCP_DEV_ATTR(adapter, port_remove, S_IWUSR, NULL,
234 zfcp_sysfs_port_remove_store);
236 static struct attribute *zfcp_adapter_attrs[] = {
237 &dev_attr_adapter_failed.attr,
238 &dev_attr_adapter_in_recovery.attr,
239 &dev_attr_adapter_port_remove.attr,
240 &dev_attr_adapter_port_rescan.attr,
241 &dev_attr_adapter_peer_wwnn.attr,
242 &dev_attr_adapter_peer_wwpn.attr,
243 &dev_attr_adapter_peer_d_id.attr,
244 &dev_attr_adapter_card_version.attr,
245 &dev_attr_adapter_lic_version.attr,
246 &dev_attr_adapter_status.attr,
247 &dev_attr_adapter_hardware_version.attr,
251 struct attribute_group zfcp_sysfs_adapter_attrs = {
252 .attrs = zfcp_adapter_attrs,
255 static ssize_t zfcp_sysfs_unit_add_store(struct device *dev,
256 struct device_attribute *attr,
257 const char *buf, size_t count)
259 struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
260 struct zfcp_unit *unit;
262 int retval = -EINVAL;
264 if (!(port && get_device(&port->dev)))
267 if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
270 unit = zfcp_unit_enqueue(port, fcp_lun);
276 zfcp_erp_unit_reopen(unit, 0, "syuas_1", NULL);
277 zfcp_erp_wait(unit->port->adapter);
278 zfcp_scsi_scan(unit);
280 put_device(&port->dev);
281 return retval ? retval : (ssize_t) count;
283 static DEVICE_ATTR(unit_add, S_IWUSR, NULL, zfcp_sysfs_unit_add_store);
285 static ssize_t zfcp_sysfs_unit_remove_store(struct device *dev,
286 struct device_attribute *attr,
287 const char *buf, size_t count)
289 struct zfcp_port *port = container_of(dev, struct zfcp_port, dev);
290 struct zfcp_unit *unit;
292 int retval = -EINVAL;
293 struct scsi_device *sdev;
295 if (!(port && get_device(&port->dev)))
298 if (strict_strtoull(buf, 0, (unsigned long long *) &fcp_lun))
301 unit = zfcp_get_unit_by_lun(port, fcp_lun);
307 sdev = scsi_device_lookup(port->adapter->scsi_host, 0,
309 scsilun_to_int((struct scsi_lun *)&fcp_lun));
311 scsi_remove_device(sdev);
312 scsi_device_put(sdev);
315 write_lock_irq(&port->unit_list_lock);
316 list_del(&unit->list);
317 write_unlock_irq(&port->unit_list_lock);
319 put_device(&unit->dev);
321 zfcp_erp_unit_shutdown(unit, 0, "syurs_1", NULL);
322 zfcp_device_unregister(&unit->dev, &zfcp_sysfs_unit_attrs);
324 put_device(&port->dev);
325 return retval ? retval : (ssize_t) count;
327 static DEVICE_ATTR(unit_remove, S_IWUSR, NULL, zfcp_sysfs_unit_remove_store);
329 static struct attribute *zfcp_port_attrs[] = {
330 &dev_attr_unit_add.attr,
331 &dev_attr_unit_remove.attr,
332 &dev_attr_port_failed.attr,
333 &dev_attr_port_in_recovery.attr,
334 &dev_attr_port_status.attr,
335 &dev_attr_port_access_denied.attr,
340 * zfcp_sysfs_port_attrs - sysfs attributes for all other ports
342 struct attribute_group zfcp_sysfs_port_attrs = {
343 .attrs = zfcp_port_attrs,
346 static struct attribute *zfcp_unit_attrs[] = {
347 &dev_attr_unit_failed.attr,
348 &dev_attr_unit_in_recovery.attr,
349 &dev_attr_unit_status.attr,
350 &dev_attr_unit_access_denied.attr,
351 &dev_attr_unit_access_shared.attr,
352 &dev_attr_unit_access_readonly.attr,
356 struct attribute_group zfcp_sysfs_unit_attrs = {
357 .attrs = zfcp_unit_attrs,
360 #define ZFCP_DEFINE_LATENCY_ATTR(_name) \
362 zfcp_sysfs_unit_##_name##_latency_show(struct device *dev, \
363 struct device_attribute *attr, \
365 struct scsi_device *sdev = to_scsi_device(dev); \
366 struct zfcp_unit *unit = sdev->hostdata; \
367 struct zfcp_latencies *lat = &unit->latencies; \
368 struct zfcp_adapter *adapter = unit->port->adapter; \
369 unsigned long long fsum, fmin, fmax, csum, cmin, cmax, cc; \
371 spin_lock_bh(&lat->lock); \
372 fsum = lat->_name.fabric.sum * adapter->timer_ticks; \
373 fmin = lat->_name.fabric.min * adapter->timer_ticks; \
374 fmax = lat->_name.fabric.max * adapter->timer_ticks; \
375 csum = lat->_name.channel.sum * adapter->timer_ticks; \
376 cmin = lat->_name.channel.min * adapter->timer_ticks; \
377 cmax = lat->_name.channel.max * adapter->timer_ticks; \
378 cc = lat->_name.counter; \
379 spin_unlock_bh(&lat->lock); \
381 do_div(fsum, 1000); \
382 do_div(fmin, 1000); \
383 do_div(fmax, 1000); \
384 do_div(csum, 1000); \
385 do_div(cmin, 1000); \
386 do_div(cmax, 1000); \
388 return sprintf(buf, "%llu %llu %llu %llu %llu %llu %llu\n", \
389 fmin, fmax, fsum, cmin, cmax, csum, cc); \
392 zfcp_sysfs_unit_##_name##_latency_store(struct device *dev, \
393 struct device_attribute *attr, \
394 const char *buf, size_t count) \
396 struct scsi_device *sdev = to_scsi_device(dev); \
397 struct zfcp_unit *unit = sdev->hostdata; \
398 struct zfcp_latencies *lat = &unit->latencies; \
399 unsigned long flags; \
401 spin_lock_irqsave(&lat->lock, flags); \
402 lat->_name.fabric.sum = 0; \
403 lat->_name.fabric.min = 0xFFFFFFFF; \
404 lat->_name.fabric.max = 0; \
405 lat->_name.channel.sum = 0; \
406 lat->_name.channel.min = 0xFFFFFFFF; \
407 lat->_name.channel.max = 0; \
408 lat->_name.counter = 0; \
409 spin_unlock_irqrestore(&lat->lock, flags); \
411 return (ssize_t) count; \
413 static DEVICE_ATTR(_name##_latency, S_IWUSR | S_IRUGO, \
414 zfcp_sysfs_unit_##_name##_latency_show, \
415 zfcp_sysfs_unit_##_name##_latency_store);
417 ZFCP_DEFINE_LATENCY_ATTR(read);
418 ZFCP_DEFINE_LATENCY_ATTR(write);
419 ZFCP_DEFINE_LATENCY_ATTR(cmd);
421 #define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \
422 static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, \
423 struct device_attribute *attr,\
426 struct scsi_device *sdev = to_scsi_device(dev); \
427 struct zfcp_unit *unit = sdev->hostdata; \
429 return sprintf(buf, _format, _value); \
431 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL);
433 ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n",
434 dev_name(&unit->port->adapter->ccw_device->dev));
435 ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n",
436 (unsigned long long) unit->port->wwpn);
437 ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n",
438 (unsigned long long) unit->fcp_lun);
440 struct device_attribute *zfcp_sysfs_sdev_attrs[] = {
444 &dev_attr_read_latency,
445 &dev_attr_write_latency,
446 &dev_attr_cmd_latency,
450 static ssize_t zfcp_sysfs_adapter_util_show(struct device *dev,
451 struct device_attribute *attr,
454 struct Scsi_Host *scsi_host = dev_to_shost(dev);
455 struct fsf_qtcb_bottom_port *qtcb_port;
456 struct zfcp_adapter *adapter;
459 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
460 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
463 qtcb_port = kzalloc(sizeof(struct fsf_qtcb_bottom_port), GFP_KERNEL);
467 retval = zfcp_fsf_exchange_port_data_sync(adapter->qdio, qtcb_port);
469 retval = sprintf(buf, "%u %u %u\n", qtcb_port->cp_util,
470 qtcb_port->cb_util, qtcb_port->a_util);
474 static DEVICE_ATTR(utilization, S_IRUGO, zfcp_sysfs_adapter_util_show, NULL);
476 static int zfcp_sysfs_adapter_ex_config(struct device *dev,
477 struct fsf_statistics_info *stat_inf)
479 struct Scsi_Host *scsi_host = dev_to_shost(dev);
480 struct fsf_qtcb_bottom_config *qtcb_config;
481 struct zfcp_adapter *adapter;
484 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0];
485 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA))
488 qtcb_config = kzalloc(sizeof(struct fsf_qtcb_bottom_config),
493 retval = zfcp_fsf_exchange_config_data_sync(adapter->qdio, qtcb_config);
495 *stat_inf = qtcb_config->stat_info;
501 #define ZFCP_SHOST_ATTR(_name, _format, _arg...) \
502 static ssize_t zfcp_sysfs_adapter_##_name##_show(struct device *dev, \
503 struct device_attribute *attr,\
506 struct fsf_statistics_info stat_info; \
509 retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info); \
513 return sprintf(buf, _format, ## _arg); \
515 static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_adapter_##_name##_show, NULL);
517 ZFCP_SHOST_ATTR(requests, "%llu %llu %llu\n",
518 (unsigned long long) stat_info.input_req,
519 (unsigned long long) stat_info.output_req,
520 (unsigned long long) stat_info.control_req);
522 ZFCP_SHOST_ATTR(megabytes, "%llu %llu\n",
523 (unsigned long long) stat_info.input_mb,
524 (unsigned long long) stat_info.output_mb);
526 ZFCP_SHOST_ATTR(seconds_active, "%llu\n",
527 (unsigned long long) stat_info.seconds_act);
529 static ssize_t zfcp_sysfs_adapter_q_full_show(struct device *dev,
530 struct device_attribute *attr,
533 struct Scsi_Host *scsi_host = class_to_shost(dev);
534 struct zfcp_qdio *qdio =
535 ((struct zfcp_adapter *) scsi_host->hostdata[0])->qdio;
538 spin_lock_bh(&qdio->stat_lock);
539 util = qdio->req_q_util;
540 spin_unlock_bh(&qdio->stat_lock);
542 return sprintf(buf, "%d %llu\n", atomic_read(&qdio->req_q_full),
543 (unsigned long long)util);
545 static DEVICE_ATTR(queue_full, S_IRUGO, zfcp_sysfs_adapter_q_full_show, NULL);
547 struct device_attribute *zfcp_sysfs_shost_attrs[] = {
548 &dev_attr_utilization,
551 &dev_attr_seconds_active,
552 &dev_attr_queue_full,