zfcp_scsi.c revision f76af7d7e36373179be7a9e09f6b0aae330549b7
1/* 2 * zfcp device driver 3 * 4 * Interface to Linux SCSI midlayer. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9#include "zfcp_ext.h" 10#include <asm/atomic.h> 11 12/* Find start of Sense Information in FCP response unit*/ 13char *zfcp_get_fcp_sns_info_ptr(struct fcp_rsp_iu *fcp_rsp_iu) 14{ 15 char *fcp_sns_info_ptr; 16 17 fcp_sns_info_ptr = (unsigned char *) &fcp_rsp_iu[1]; 18 if (fcp_rsp_iu->validity.bits.fcp_rsp_len_valid) 19 fcp_sns_info_ptr += fcp_rsp_iu->fcp_rsp_len; 20 21 return fcp_sns_info_ptr; 22} 23 24void zfcp_set_fcp_dl(struct fcp_cmnd_iu *fcp_cmd, fcp_dl_t fcp_dl) 25{ 26 fcp_dl_t *fcp_dl_ptr; 27 28 /* 29 * fcp_dl_addr = start address of fcp_cmnd structure + 30 * size of fixed part + size of dynamically sized add_dcp_cdb field 31 * SEE FCP-2 documentation 32 */ 33 fcp_dl_ptr = (fcp_dl_t *) ((unsigned char *) &fcp_cmd[1] + 34 (fcp_cmd->add_fcp_cdb_length << 2)); 35 *fcp_dl_ptr = fcp_dl; 36} 37 38static void zfcp_scsi_slave_destroy(struct scsi_device *sdpnt) 39{ 40 struct zfcp_unit *unit = (struct zfcp_unit *) sdpnt->hostdata; 41 WARN_ON(!unit); 42 if (unit) { 43 atomic_clear_mask(ZFCP_STATUS_UNIT_REGISTERED, &unit->status); 44 sdpnt->hostdata = NULL; 45 unit->device = NULL; 46 zfcp_erp_unit_failed(unit, 12, NULL); 47 zfcp_unit_put(unit); 48 } 49} 50 51static int zfcp_scsi_slave_configure(struct scsi_device *sdp) 52{ 53 if (sdp->tagged_supported) 54 scsi_adjust_queue_depth(sdp, MSG_SIMPLE_TAG, 32); 55 else 56 scsi_adjust_queue_depth(sdp, 0, 1); 57 return 0; 58} 59 60static void zfcp_scsi_command_fail(struct scsi_cmnd *scpnt, int result) 61{ 62 set_host_byte(scpnt, result); 63 if ((scpnt->device != NULL) && (scpnt->device->host != NULL)) 64 zfcp_scsi_dbf_event_result("fail", 4, 65 (struct zfcp_adapter*) scpnt->device->host->hostdata[0], 66 scpnt, NULL); 67 /* return directly */ 68 scpnt->scsi_done(scpnt); 69} 70 71static int zfcp_scsi_queuecommand(struct scsi_cmnd *scpnt, 72 void (*done) (struct scsi_cmnd *)) 73{ 74 struct zfcp_unit *unit; 75 struct zfcp_adapter *adapter; 76 int status; 77 int ret; 78 79 /* reset the status for this request */ 80 scpnt->result = 0; 81 scpnt->host_scribble = NULL; 82 scpnt->scsi_done = done; 83 84 /* 85 * figure out adapter and target device 86 * (stored there by zfcp_scsi_slave_alloc) 87 */ 88 adapter = (struct zfcp_adapter *) scpnt->device->host->hostdata[0]; 89 unit = scpnt->device->hostdata; 90 91 BUG_ON(!adapter || (adapter != unit->port->adapter)); 92 BUG_ON(!scpnt->scsi_done); 93 94 if (unlikely(!unit)) { 95 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); 96 return 0; 97 } 98 99 status = atomic_read(&unit->status); 100 if (unlikely((status & ZFCP_STATUS_COMMON_ERP_FAILED) || 101 !(status & ZFCP_STATUS_COMMON_RUNNING))) { 102 zfcp_scsi_command_fail(scpnt, DID_ERROR); 103 return 0;; 104 } 105 106 ret = zfcp_fsf_send_fcp_command_task(adapter, unit, scpnt, 0, 107 ZFCP_REQ_AUTO_CLEANUP); 108 if (unlikely(ret == -EBUSY)) 109 zfcp_scsi_command_fail(scpnt, DID_NO_CONNECT); 110 else if (unlikely(ret < 0)) 111 return SCSI_MLQUEUE_HOST_BUSY; 112 113 return ret; 114} 115 116static struct zfcp_unit *zfcp_unit_lookup(struct zfcp_adapter *adapter, 117 int channel, unsigned int id, 118 unsigned int lun) 119{ 120 struct zfcp_port *port; 121 struct zfcp_unit *unit; 122 123 list_for_each_entry(port, &adapter->port_list_head, list) { 124 if (!port->rport || (id != port->rport->scsi_target_id)) 125 continue; 126 list_for_each_entry(unit, &port->unit_list_head, list) 127 if (lun == unit->scsi_lun) 128 return unit; 129 } 130 131 return NULL; 132} 133 134static int zfcp_scsi_slave_alloc(struct scsi_device *sdp) 135{ 136 struct zfcp_adapter *adapter; 137 struct zfcp_unit *unit; 138 unsigned long flags; 139 int retval = -ENXIO; 140 141 adapter = (struct zfcp_adapter *) sdp->host->hostdata[0]; 142 if (!adapter) 143 goto out; 144 145 read_lock_irqsave(&zfcp_data.config_lock, flags); 146 unit = zfcp_unit_lookup(adapter, sdp->channel, sdp->id, sdp->lun); 147 if (unit && 148 (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_REGISTERED)) { 149 sdp->hostdata = unit; 150 unit->device = sdp; 151 zfcp_unit_get(unit); 152 retval = 0; 153 } 154 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 155out: 156 return retval; 157} 158 159static int zfcp_scsi_eh_abort_handler(struct scsi_cmnd *scpnt) 160{ 161 struct Scsi_Host *scsi_host; 162 struct zfcp_adapter *adapter; 163 struct zfcp_unit *unit; 164 struct zfcp_fsf_req *fsf_req; 165 unsigned long flags; 166 unsigned long old_req_id = (unsigned long) scpnt->host_scribble; 167 int retval = SUCCESS; 168 169 scsi_host = scpnt->device->host; 170 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0]; 171 unit = scpnt->device->hostdata; 172 173 /* avoid race condition between late normal completion and abort */ 174 write_lock_irqsave(&adapter->abort_lock, flags); 175 176 /* Check whether corresponding fsf_req is still pending */ 177 spin_lock(&adapter->req_list_lock); 178 fsf_req = zfcp_reqlist_find(adapter, old_req_id); 179 spin_unlock(&adapter->req_list_lock); 180 if (!fsf_req) { 181 write_unlock_irqrestore(&adapter->abort_lock, flags); 182 zfcp_scsi_dbf_event_abort("lte1", adapter, scpnt, NULL, 0); 183 return retval; 184 } 185 fsf_req->data = 0; 186 fsf_req->status |= ZFCP_STATUS_FSFREQ_ABORTING; 187 188 /* don't access old fsf_req after releasing the abort_lock */ 189 write_unlock_irqrestore(&adapter->abort_lock, flags); 190 191 fsf_req = zfcp_fsf_abort_fcp_command(old_req_id, adapter, unit, 0); 192 if (!fsf_req) { 193 zfcp_scsi_dbf_event_abort("nres", adapter, scpnt, NULL, 194 old_req_id); 195 retval = FAILED; 196 return retval; 197 } 198 199 __wait_event(fsf_req->completion_wq, 200 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 201 202 if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED) { 203 zfcp_scsi_dbf_event_abort("okay", adapter, scpnt, fsf_req, 0); 204 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED) { 205 zfcp_scsi_dbf_event_abort("lte2", adapter, scpnt, fsf_req, 0); 206 } else { 207 zfcp_scsi_dbf_event_abort("fail", adapter, scpnt, fsf_req, 0); 208 retval = FAILED; 209 } 210 zfcp_fsf_req_free(fsf_req); 211 212 return retval; 213} 214 215static int zfcp_task_mgmt_function(struct zfcp_unit *unit, u8 tm_flags, 216 struct scsi_cmnd *scpnt) 217{ 218 struct zfcp_adapter *adapter = unit->port->adapter; 219 struct zfcp_fsf_req *fsf_req; 220 int retval = SUCCESS; 221 222 /* issue task management function */ 223 fsf_req = zfcp_fsf_send_fcp_command_task_management 224 (adapter, unit, tm_flags, 0); 225 if (!fsf_req) { 226 zfcp_scsi_dbf_event_devreset("nres", tm_flags, unit, scpnt); 227 return FAILED; 228 } 229 230 __wait_event(fsf_req->completion_wq, 231 fsf_req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 232 233 /* 234 * check completion status of task management function 235 */ 236 if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCFAILED) { 237 zfcp_scsi_dbf_event_devreset("fail", tm_flags, unit, scpnt); 238 retval = FAILED; 239 } else if (fsf_req->status & ZFCP_STATUS_FSFREQ_TMFUNCNOTSUPP) { 240 zfcp_scsi_dbf_event_devreset("nsup", tm_flags, unit, scpnt); 241 retval = FAILED; 242 } else 243 zfcp_scsi_dbf_event_devreset("okay", tm_flags, unit, scpnt); 244 245 zfcp_fsf_req_free(fsf_req); 246 247 return retval; 248} 249 250static int zfcp_scsi_eh_device_reset_handler(struct scsi_cmnd *scpnt) 251{ 252 struct zfcp_unit *unit = scpnt->device->hostdata; 253 254 if (!unit) { 255 WARN_ON(1); 256 return SUCCESS; 257 } 258 return zfcp_task_mgmt_function(unit, FCP_LOGICAL_UNIT_RESET, scpnt); 259} 260 261static int zfcp_scsi_eh_target_reset_handler(struct scsi_cmnd *scpnt) 262{ 263 struct zfcp_unit *unit = scpnt->device->hostdata; 264 265 if (!unit) { 266 WARN_ON(1); 267 return SUCCESS; 268 } 269 return zfcp_task_mgmt_function(unit, FCP_TARGET_RESET, scpnt); 270} 271 272static int zfcp_scsi_eh_host_reset_handler(struct scsi_cmnd *scpnt) 273{ 274 struct zfcp_unit *unit; 275 struct zfcp_adapter *adapter; 276 277 unit = scpnt->device->hostdata; 278 adapter = unit->port->adapter; 279 zfcp_erp_adapter_reopen(adapter, 0, 141, scpnt); 280 zfcp_erp_wait(adapter); 281 282 return SUCCESS; 283} 284 285int zfcp_adapter_scsi_register(struct zfcp_adapter *adapter) 286{ 287 struct ccw_dev_id dev_id; 288 289 if (adapter->scsi_host) 290 return 0; 291 292 ccw_device_get_id(adapter->ccw_device, &dev_id); 293 /* register adapter as SCSI host with mid layer of SCSI stack */ 294 adapter->scsi_host = scsi_host_alloc(&zfcp_data.scsi_host_template, 295 sizeof (struct zfcp_adapter *)); 296 if (!adapter->scsi_host) { 297 dev_err(&adapter->ccw_device->dev, 298 "registration with SCSI stack failed."); 299 return -EIO; 300 } 301 302 /* tell the SCSI stack some characteristics of this adapter */ 303 adapter->scsi_host->max_id = 1; 304 adapter->scsi_host->max_lun = 1; 305 adapter->scsi_host->max_channel = 0; 306 adapter->scsi_host->unique_id = dev_id.devno; 307 adapter->scsi_host->max_cmd_len = 255; 308 adapter->scsi_host->transportt = zfcp_data.scsi_transport_template; 309 310 adapter->scsi_host->hostdata[0] = (unsigned long) adapter; 311 312 if (scsi_add_host(adapter->scsi_host, &adapter->ccw_device->dev)) { 313 scsi_host_put(adapter->scsi_host); 314 return -EIO; 315 } 316 atomic_set_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status); 317 318 return 0; 319} 320 321void zfcp_adapter_scsi_unregister(struct zfcp_adapter *adapter) 322{ 323 struct Scsi_Host *shost; 324 struct zfcp_port *port; 325 326 shost = adapter->scsi_host; 327 if (!shost) 328 return; 329 330 read_lock_irq(&zfcp_data.config_lock); 331 list_for_each_entry(port, &adapter->port_list_head, list) 332 if (port->rport) 333 port->rport = NULL; 334 335 read_unlock_irq(&zfcp_data.config_lock); 336 fc_remove_host(shost); 337 scsi_remove_host(shost); 338 scsi_host_put(shost); 339 adapter->scsi_host = NULL; 340 atomic_clear_mask(ZFCP_STATUS_ADAPTER_REGISTERED, &adapter->status); 341 342 return; 343} 344 345static struct fc_host_statistics* 346zfcp_init_fc_host_stats(struct zfcp_adapter *adapter) 347{ 348 struct fc_host_statistics *fc_stats; 349 350 if (!adapter->fc_stats) { 351 fc_stats = kmalloc(sizeof(*fc_stats), GFP_KERNEL); 352 if (!fc_stats) 353 return NULL; 354 adapter->fc_stats = fc_stats; /* freed in adater_dequeue */ 355 } 356 memset(adapter->fc_stats, 0, sizeof(*adapter->fc_stats)); 357 return adapter->fc_stats; 358} 359 360static void zfcp_adjust_fc_host_stats(struct fc_host_statistics *fc_stats, 361 struct fsf_qtcb_bottom_port *data, 362 struct fsf_qtcb_bottom_port *old) 363{ 364 fc_stats->seconds_since_last_reset = 365 data->seconds_since_last_reset - old->seconds_since_last_reset; 366 fc_stats->tx_frames = data->tx_frames - old->tx_frames; 367 fc_stats->tx_words = data->tx_words - old->tx_words; 368 fc_stats->rx_frames = data->rx_frames - old->rx_frames; 369 fc_stats->rx_words = data->rx_words - old->rx_words; 370 fc_stats->lip_count = data->lip - old->lip; 371 fc_stats->nos_count = data->nos - old->nos; 372 fc_stats->error_frames = data->error_frames - old->error_frames; 373 fc_stats->dumped_frames = data->dumped_frames - old->dumped_frames; 374 fc_stats->link_failure_count = data->link_failure - old->link_failure; 375 fc_stats->loss_of_sync_count = data->loss_of_sync - old->loss_of_sync; 376 fc_stats->loss_of_signal_count = 377 data->loss_of_signal - old->loss_of_signal; 378 fc_stats->prim_seq_protocol_err_count = 379 data->psp_error_counts - old->psp_error_counts; 380 fc_stats->invalid_tx_word_count = 381 data->invalid_tx_words - old->invalid_tx_words; 382 fc_stats->invalid_crc_count = data->invalid_crcs - old->invalid_crcs; 383 fc_stats->fcp_input_requests = 384 data->input_requests - old->input_requests; 385 fc_stats->fcp_output_requests = 386 data->output_requests - old->output_requests; 387 fc_stats->fcp_control_requests = 388 data->control_requests - old->control_requests; 389 fc_stats->fcp_input_megabytes = data->input_mb - old->input_mb; 390 fc_stats->fcp_output_megabytes = data->output_mb - old->output_mb; 391} 392 393static void zfcp_set_fc_host_stats(struct fc_host_statistics *fc_stats, 394 struct fsf_qtcb_bottom_port *data) 395{ 396 fc_stats->seconds_since_last_reset = data->seconds_since_last_reset; 397 fc_stats->tx_frames = data->tx_frames; 398 fc_stats->tx_words = data->tx_words; 399 fc_stats->rx_frames = data->rx_frames; 400 fc_stats->rx_words = data->rx_words; 401 fc_stats->lip_count = data->lip; 402 fc_stats->nos_count = data->nos; 403 fc_stats->error_frames = data->error_frames; 404 fc_stats->dumped_frames = data->dumped_frames; 405 fc_stats->link_failure_count = data->link_failure; 406 fc_stats->loss_of_sync_count = data->loss_of_sync; 407 fc_stats->loss_of_signal_count = data->loss_of_signal; 408 fc_stats->prim_seq_protocol_err_count = data->psp_error_counts; 409 fc_stats->invalid_tx_word_count = data->invalid_tx_words; 410 fc_stats->invalid_crc_count = data->invalid_crcs; 411 fc_stats->fcp_input_requests = data->input_requests; 412 fc_stats->fcp_output_requests = data->output_requests; 413 fc_stats->fcp_control_requests = data->control_requests; 414 fc_stats->fcp_input_megabytes = data->input_mb; 415 fc_stats->fcp_output_megabytes = data->output_mb; 416} 417 418static struct fc_host_statistics *zfcp_get_fc_host_stats(struct Scsi_Host *host) 419{ 420 struct zfcp_adapter *adapter; 421 struct fc_host_statistics *fc_stats; 422 struct fsf_qtcb_bottom_port *data; 423 int ret; 424 425 adapter = (struct zfcp_adapter *)host->hostdata[0]; 426 fc_stats = zfcp_init_fc_host_stats(adapter); 427 if (!fc_stats) 428 return NULL; 429 430 data = kzalloc(sizeof(*data), GFP_KERNEL); 431 if (!data) 432 return NULL; 433 434 ret = zfcp_fsf_exchange_port_data_sync(adapter, data); 435 if (ret) { 436 kfree(data); 437 return NULL; 438 } 439 440 if (adapter->stats_reset && 441 ((jiffies/HZ - adapter->stats_reset) < 442 data->seconds_since_last_reset)) 443 zfcp_adjust_fc_host_stats(fc_stats, data, 444 adapter->stats_reset_data); 445 else 446 zfcp_set_fc_host_stats(fc_stats, data); 447 448 kfree(data); 449 return fc_stats; 450} 451 452static void zfcp_reset_fc_host_stats(struct Scsi_Host *shost) 453{ 454 struct zfcp_adapter *adapter; 455 struct fsf_qtcb_bottom_port *data; 456 int ret; 457 458 adapter = (struct zfcp_adapter *)shost->hostdata[0]; 459 data = kzalloc(sizeof(*data), GFP_KERNEL); 460 if (!data) 461 return; 462 463 ret = zfcp_fsf_exchange_port_data_sync(adapter, data); 464 if (ret) 465 kfree(data); 466 else { 467 adapter->stats_reset = jiffies/HZ; 468 kfree(adapter->stats_reset_data); 469 adapter->stats_reset_data = data; /* finally freed in 470 adapter_dequeue */ 471 } 472} 473 474static void zfcp_get_host_port_state(struct Scsi_Host *shost) 475{ 476 struct zfcp_adapter *adapter = 477 (struct zfcp_adapter *)shost->hostdata[0]; 478 int status = atomic_read(&adapter->status); 479 480 if ((status & ZFCP_STATUS_COMMON_RUNNING) && 481 !(status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED)) 482 fc_host_port_state(shost) = FC_PORTSTATE_ONLINE; 483 else if (status & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED) 484 fc_host_port_state(shost) = FC_PORTSTATE_LINKDOWN; 485 else if (status & ZFCP_STATUS_COMMON_ERP_FAILED) 486 fc_host_port_state(shost) = FC_PORTSTATE_ERROR; 487 else 488 fc_host_port_state(shost) = FC_PORTSTATE_UNKNOWN; 489} 490 491static void zfcp_set_rport_dev_loss_tmo(struct fc_rport *rport, u32 timeout) 492{ 493 rport->dev_loss_tmo = timeout; 494} 495 496struct fc_function_template zfcp_transport_functions = { 497 .show_starget_port_id = 1, 498 .show_starget_port_name = 1, 499 .show_starget_node_name = 1, 500 .show_rport_supported_classes = 1, 501 .show_rport_maxframe_size = 1, 502 .show_rport_dev_loss_tmo = 1, 503 .show_host_node_name = 1, 504 .show_host_port_name = 1, 505 .show_host_permanent_port_name = 1, 506 .show_host_supported_classes = 1, 507 .show_host_supported_speeds = 1, 508 .show_host_maxframe_size = 1, 509 .show_host_serial_number = 1, 510 .get_fc_host_stats = zfcp_get_fc_host_stats, 511 .reset_fc_host_stats = zfcp_reset_fc_host_stats, 512 .set_rport_dev_loss_tmo = zfcp_set_rport_dev_loss_tmo, 513 .get_host_port_state = zfcp_get_host_port_state, 514 .show_host_port_state = 1, 515 /* no functions registered for following dynamic attributes but 516 directly set by LLDD */ 517 .show_host_port_type = 1, 518 .show_host_speed = 1, 519 .show_host_port_id = 1, 520 .disable_target_scan = 1, 521}; 522 523#define ZFCP_DEFINE_LATENCY_ATTR(_name) \ 524static ssize_t \ 525zfcp_sysfs_unit_##_name##_latency_show(struct device *dev, \ 526 struct device_attribute *attr, \ 527 char *buf) { \ 528 struct scsi_device *sdev = to_scsi_device(dev); \ 529 struct zfcp_unit *unit = sdev->hostdata; \ 530 struct zfcp_latencies *lat = &unit->latencies; \ 531 struct zfcp_adapter *adapter = unit->port->adapter; \ 532 unsigned long flags; \ 533 unsigned long long fsum, fmin, fmax, csum, cmin, cmax, cc; \ 534 \ 535 spin_lock_irqsave(&lat->lock, flags); \ 536 fsum = lat->_name.fabric.sum * adapter->timer_ticks; \ 537 fmin = lat->_name.fabric.min * adapter->timer_ticks; \ 538 fmax = lat->_name.fabric.max * adapter->timer_ticks; \ 539 csum = lat->_name.channel.sum * adapter->timer_ticks; \ 540 cmin = lat->_name.channel.min * adapter->timer_ticks; \ 541 cmax = lat->_name.channel.max * adapter->timer_ticks; \ 542 cc = lat->_name.counter; \ 543 spin_unlock_irqrestore(&lat->lock, flags); \ 544 \ 545 do_div(fsum, 1000); \ 546 do_div(fmin, 1000); \ 547 do_div(fmax, 1000); \ 548 do_div(csum, 1000); \ 549 do_div(cmin, 1000); \ 550 do_div(cmax, 1000); \ 551 \ 552 return sprintf(buf, "%llu %llu %llu %llu %llu %llu %llu\n", \ 553 fmin, fmax, fsum, cmin, cmax, csum, cc); \ 554} \ 555static ssize_t \ 556zfcp_sysfs_unit_##_name##_latency_store(struct device *dev, \ 557 struct device_attribute *attr, \ 558 const char *buf, size_t count) \ 559{ \ 560 struct scsi_device *sdev = to_scsi_device(dev); \ 561 struct zfcp_unit *unit = sdev->hostdata; \ 562 struct zfcp_latencies *lat = &unit->latencies; \ 563 unsigned long flags; \ 564 \ 565 spin_lock_irqsave(&lat->lock, flags); \ 566 lat->_name.fabric.sum = 0; \ 567 lat->_name.fabric.min = 0xFFFFFFFF; \ 568 lat->_name.fabric.max = 0; \ 569 lat->_name.channel.sum = 0; \ 570 lat->_name.channel.min = 0xFFFFFFFF; \ 571 lat->_name.channel.max = 0; \ 572 lat->_name.counter = 0; \ 573 spin_unlock_irqrestore(&lat->lock, flags); \ 574 \ 575 return (ssize_t) count; \ 576} \ 577static DEVICE_ATTR(_name##_latency, S_IWUSR | S_IRUGO, \ 578 zfcp_sysfs_unit_##_name##_latency_show, \ 579 zfcp_sysfs_unit_##_name##_latency_store); 580 581ZFCP_DEFINE_LATENCY_ATTR(read); 582ZFCP_DEFINE_LATENCY_ATTR(write); 583ZFCP_DEFINE_LATENCY_ATTR(cmd); 584 585#define ZFCP_DEFINE_SCSI_ATTR(_name, _format, _value) \ 586static ssize_t zfcp_sysfs_scsi_##_name##_show(struct device *dev, struct device_attribute *attr, \ 587 char *buf) \ 588{ \ 589 struct scsi_device *sdev; \ 590 struct zfcp_unit *unit; \ 591 \ 592 sdev = to_scsi_device(dev); \ 593 unit = sdev->hostdata; \ 594 return sprintf(buf, _format, _value); \ 595} \ 596 \ 597static DEVICE_ATTR(_name, S_IRUGO, zfcp_sysfs_scsi_##_name##_show, NULL); 598 599ZFCP_DEFINE_SCSI_ATTR(hba_id, "%s\n", 600 unit->port->adapter->ccw_device->dev.bus_id); 601ZFCP_DEFINE_SCSI_ATTR(wwpn, "0x%016llx\n", unit->port->wwpn); 602ZFCP_DEFINE_SCSI_ATTR(fcp_lun, "0x%016llx\n", unit->fcp_lun); 603 604static struct device_attribute *zfcp_sysfs_sdev_attrs[] = { 605 &dev_attr_fcp_lun, 606 &dev_attr_wwpn, 607 &dev_attr_hba_id, 608 &dev_attr_read_latency, 609 &dev_attr_write_latency, 610 &dev_attr_cmd_latency, 611 NULL 612}; 613 614static ssize_t zfcp_sysfs_adapter_util_show(struct device *dev, 615 struct device_attribute *attr, 616 char *buf) 617{ 618 struct Scsi_Host *scsi_host = dev_to_shost(dev); 619 struct fsf_qtcb_bottom_port *qtcb_port; 620 struct zfcp_adapter *adapter; 621 int retval; 622 623 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0]; 624 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)) 625 return -EOPNOTSUPP; 626 627 qtcb_port = kzalloc(sizeof(struct fsf_qtcb_bottom_port), GFP_KERNEL); 628 if (!qtcb_port) 629 return -ENOMEM; 630 631 retval = zfcp_fsf_exchange_port_data_sync(adapter, qtcb_port); 632 if (!retval) 633 retval = sprintf(buf, "%u %u %u\n", qtcb_port->cp_util, 634 qtcb_port->cb_util, qtcb_port->a_util); 635 kfree(qtcb_port); 636 return retval; 637} 638 639static int zfcp_sysfs_adapter_ex_config(struct device *dev, 640 struct fsf_statistics_info *stat_inf) 641{ 642 struct Scsi_Host *scsi_host = dev_to_shost(dev); 643 struct fsf_qtcb_bottom_config *qtcb_config; 644 struct zfcp_adapter *adapter; 645 int retval; 646 647 adapter = (struct zfcp_adapter *) scsi_host->hostdata[0]; 648 if (!(adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA)) 649 return -EOPNOTSUPP; 650 651 qtcb_config = kzalloc(sizeof(struct fsf_qtcb_bottom_config), 652 GFP_KERNEL); 653 if (!qtcb_config) 654 return -ENOMEM; 655 656 retval = zfcp_fsf_exchange_config_data_sync(adapter, qtcb_config); 657 if (!retval) 658 *stat_inf = qtcb_config->stat_info; 659 660 kfree(qtcb_config); 661 return retval; 662} 663 664static ssize_t zfcp_sysfs_adapter_request_show(struct device *dev, 665 struct device_attribute *attr, 666 char *buf) 667{ 668 struct fsf_statistics_info stat_info; 669 int retval; 670 671 retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info); 672 if (retval) 673 return retval; 674 675 return sprintf(buf, "%llu %llu %llu\n", 676 (unsigned long long) stat_info.input_req, 677 (unsigned long long) stat_info.output_req, 678 (unsigned long long) stat_info.control_req); 679} 680 681static ssize_t zfcp_sysfs_adapter_mb_show(struct device *dev, 682 struct device_attribute *attr, 683 char *buf) 684{ 685 struct fsf_statistics_info stat_info; 686 int retval; 687 688 retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info); 689 if (retval) 690 return retval; 691 692 return sprintf(buf, "%llu %llu\n", 693 (unsigned long long) stat_info.input_mb, 694 (unsigned long long) stat_info.output_mb); 695} 696 697static ssize_t zfcp_sysfs_adapter_sec_active_show(struct device *dev, 698 struct device_attribute *attr, 699 char *buf) 700{ 701 struct fsf_statistics_info stat_info; 702 int retval; 703 704 retval = zfcp_sysfs_adapter_ex_config(dev, &stat_info); 705 if (retval) 706 return retval; 707 708 return sprintf(buf, "%llu\n", 709 (unsigned long long) stat_info.seconds_act); 710} 711 712static DEVICE_ATTR(utilization, S_IRUGO, zfcp_sysfs_adapter_util_show, NULL); 713static DEVICE_ATTR(requests, S_IRUGO, zfcp_sysfs_adapter_request_show, NULL); 714static DEVICE_ATTR(megabytes, S_IRUGO, zfcp_sysfs_adapter_mb_show, NULL); 715static DEVICE_ATTR(seconds_active, S_IRUGO, 716 zfcp_sysfs_adapter_sec_active_show, NULL); 717 718static struct device_attribute *zfcp_a_stats_attrs[] = { 719 &dev_attr_utilization, 720 &dev_attr_requests, 721 &dev_attr_megabytes, 722 &dev_attr_seconds_active, 723 NULL 724}; 725 726struct zfcp_data zfcp_data = { 727 .scsi_host_template = { 728 .name = "zfcp", 729 .module = THIS_MODULE, 730 .proc_name = "zfcp", 731 .slave_alloc = zfcp_scsi_slave_alloc, 732 .slave_configure = zfcp_scsi_slave_configure, 733 .slave_destroy = zfcp_scsi_slave_destroy, 734 .queuecommand = zfcp_scsi_queuecommand, 735 .eh_abort_handler = zfcp_scsi_eh_abort_handler, 736 .eh_device_reset_handler = zfcp_scsi_eh_device_reset_handler, 737 .eh_target_reset_handler = zfcp_scsi_eh_target_reset_handler, 738 .eh_host_reset_handler = zfcp_scsi_eh_host_reset_handler, 739 .can_queue = 4096, 740 .this_id = -1, 741 .sg_tablesize = ZFCP_MAX_SBALES_PER_REQ, 742 .cmd_per_lun = 1, 743 .use_clustering = 1, 744 .sdev_attrs = zfcp_sysfs_sdev_attrs, 745 .max_sectors = (ZFCP_MAX_SBALES_PER_REQ * 8), 746 .shost_attrs = zfcp_a_stats_attrs, 747 }, 748}; 749 750