1 /* 2 * zfcp device driver 3 * 4 * Implementation of FSF commands. 5 * 6 * Copyright IBM Corporation 2002, 2008 7 */ 8 9 #include "zfcp_ext.h" 10 11 static void zfcp_fsf_request_timeout_handler(unsigned long data) 12 { 13 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data; 14 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, 62, 15 NULL); 16 } 17 18 static void zfcp_fsf_start_timer(struct zfcp_fsf_req *fsf_req, 19 unsigned long timeout) 20 { 21 fsf_req->timer.function = zfcp_fsf_request_timeout_handler; 22 fsf_req->timer.data = (unsigned long) fsf_req->adapter; 23 fsf_req->timer.expires = jiffies + timeout; 24 add_timer(&fsf_req->timer); 25 } 26 27 static void zfcp_fsf_start_erp_timer(struct zfcp_fsf_req *fsf_req) 28 { 29 BUG_ON(!fsf_req->erp_action); 30 fsf_req->timer.function = zfcp_erp_timeout_handler; 31 fsf_req->timer.data = (unsigned long) fsf_req->erp_action; 32 fsf_req->timer.expires = jiffies + 30 * HZ; 33 add_timer(&fsf_req->timer); 34 } 35 36 /* association between FSF command and FSF QTCB type */ 37 static u32 fsf_qtcb_type[] = { 38 [FSF_QTCB_FCP_CMND] = FSF_IO_COMMAND, 39 [FSF_QTCB_ABORT_FCP_CMND] = FSF_SUPPORT_COMMAND, 40 [FSF_QTCB_OPEN_PORT_WITH_DID] = FSF_SUPPORT_COMMAND, 41 [FSF_QTCB_OPEN_LUN] = FSF_SUPPORT_COMMAND, 42 [FSF_QTCB_CLOSE_LUN] = FSF_SUPPORT_COMMAND, 43 [FSF_QTCB_CLOSE_PORT] = FSF_SUPPORT_COMMAND, 44 [FSF_QTCB_CLOSE_PHYSICAL_PORT] = FSF_SUPPORT_COMMAND, 45 [FSF_QTCB_SEND_ELS] = FSF_SUPPORT_COMMAND, 46 [FSF_QTCB_SEND_GENERIC] = FSF_SUPPORT_COMMAND, 47 [FSF_QTCB_EXCHANGE_CONFIG_DATA] = FSF_CONFIG_COMMAND, 48 [FSF_QTCB_EXCHANGE_PORT_DATA] = FSF_PORT_COMMAND, 49 [FSF_QTCB_DOWNLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND, 50 [FSF_QTCB_UPLOAD_CONTROL_FILE] = FSF_SUPPORT_COMMAND 51 }; 52 53 static const char *zfcp_act_subtable_type[] = { 54 "unknown", "OS", "WWPN", "DID", "LUN" 55 }; 56 57 static void zfcp_act_eval_err(struct zfcp_adapter *adapter, u32 table) 58 { 59 u16 subtable = table >> 16; 60 u16 rule = table & 0xffff; 61 62 if (subtable && subtable < ARRAY_SIZE(zfcp_act_subtable_type)) 63 dev_warn(&adapter->ccw_device->dev, 64 "Access denied in subtable %s, rule %d.\n", 65 zfcp_act_subtable_type[subtable], rule); 66 } 67 68 static void zfcp_fsf_access_denied_port(struct zfcp_fsf_req *req, 69 struct zfcp_port *port) 70 { 71 struct fsf_qtcb_header *header = &req->qtcb->header; 72 dev_warn(&req->adapter->ccw_device->dev, 73 "Access denied, cannot send command to port 0x%016Lx.\n", 74 port->wwpn); 75 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]); 76 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]); 77 zfcp_erp_port_access_denied(port, 55, req); 78 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 79 } 80 81 static void zfcp_fsf_access_denied_unit(struct zfcp_fsf_req *req, 82 struct zfcp_unit *unit) 83 { 84 struct fsf_qtcb_header *header = &req->qtcb->header; 85 dev_warn(&req->adapter->ccw_device->dev, 86 "Access denied for unit 0x%016Lx on port 0x%016Lx.\n", 87 unit->fcp_lun, unit->port->wwpn); 88 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[0]); 89 zfcp_act_eval_err(req->adapter, header->fsf_status_qual.halfword[1]); 90 zfcp_erp_unit_access_denied(unit, 59, req); 91 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 92 } 93 94 static void zfcp_fsf_class_not_supp(struct zfcp_fsf_req *req) 95 { 96 dev_err(&req->adapter->ccw_device->dev, 97 "Required FC class not supported by adapter, " 98 "shutting down adapter.\n"); 99 zfcp_erp_adapter_shutdown(req->adapter, 0, 123, req); 100 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 101 } 102 103 /** 104 * zfcp_fsf_req_free - free memory used by fsf request 105 * @fsf_req: pointer to struct zfcp_fsf_req 106 */ 107 void zfcp_fsf_req_free(struct zfcp_fsf_req *req) 108 { 109 if (likely(req->pool)) { 110 mempool_free(req, req->pool); 111 return; 112 } 113 114 if (req->qtcb) { 115 kmem_cache_free(zfcp_data.fsf_req_qtcb_cache, req); 116 return; 117 } 118 } 119 120 /** 121 * zfcp_fsf_req_dismiss_all - dismiss all fsf requests 122 * @adapter: pointer to struct zfcp_adapter 123 * 124 * Never ever call this without shutting down the adapter first. 125 * Otherwise the adapter would continue using and corrupting s390 storage. 126 * Included BUG_ON() call to ensure this is done. 127 * ERP is supposed to be the only user of this function. 128 */ 129 void zfcp_fsf_req_dismiss_all(struct zfcp_adapter *adapter) 130 { 131 struct zfcp_fsf_req *req, *tmp; 132 unsigned long flags; 133 LIST_HEAD(remove_queue); 134 unsigned int i; 135 136 BUG_ON(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP); 137 spin_lock_irqsave(&adapter->req_list_lock, flags); 138 for (i = 0; i < REQUEST_LIST_SIZE; i++) 139 list_splice_init(&adapter->req_list[i], &remove_queue); 140 spin_unlock_irqrestore(&adapter->req_list_lock, flags); 141 142 list_for_each_entry_safe(req, tmp, &remove_queue, list) { 143 list_del(&req->list); 144 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED; 145 zfcp_fsf_req_complete(req); 146 } 147 } 148 149 static void zfcp_fsf_status_read_port_closed(struct zfcp_fsf_req *req) 150 { 151 struct fsf_status_read_buffer *sr_buf = req->data; 152 struct zfcp_adapter *adapter = req->adapter; 153 struct zfcp_port *port; 154 int d_id = sr_buf->d_id & ZFCP_DID_MASK; 155 unsigned long flags; 156 157 read_lock_irqsave(&zfcp_data.config_lock, flags); 158 list_for_each_entry(port, &adapter->port_list_head, list) 159 if (port->d_id == d_id) { 160 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 161 switch (sr_buf->status_subtype) { 162 case FSF_STATUS_READ_SUB_CLOSE_PHYS_PORT: 163 zfcp_erp_port_reopen(port, 0, 101, req); 164 break; 165 case FSF_STATUS_READ_SUB_ERROR_PORT: 166 zfcp_erp_port_shutdown(port, 0, 122, req); 167 break; 168 } 169 return; 170 } 171 read_unlock_irqrestore(&zfcp_data.config_lock, flags); 172 } 173 174 static void zfcp_fsf_bit_error_threshold(struct zfcp_fsf_req *req) 175 { 176 struct zfcp_adapter *adapter = req->adapter; 177 struct fsf_status_read_buffer *sr_buf = req->data; 178 struct fsf_bit_error_payload *err = &sr_buf->payload.bit_error; 179 180 dev_warn(&adapter->ccw_device->dev, 181 "Warning: bit error threshold data " 182 "received for the adapter: " 183 "link failures = %i, loss of sync errors = %i, " 184 "loss of signal errors = %i, " 185 "primitive sequence errors = %i, " 186 "invalid transmission word errors = %i, " 187 "CRC errors = %i).\n", 188 err->link_failure_error_count, 189 err->loss_of_sync_error_count, 190 err->loss_of_signal_error_count, 191 err->primitive_sequence_error_count, 192 err->invalid_transmission_word_error_count, 193 err->crc_error_count); 194 dev_warn(&adapter->ccw_device->dev, 195 "Additional bit error threshold data of the adapter: " 196 "primitive sequence event time-outs = %i, " 197 "elastic buffer overrun errors = %i, " 198 "advertised receive buffer-to-buffer credit = %i, " 199 "current receice buffer-to-buffer credit = %i, " 200 "advertised transmit buffer-to-buffer credit = %i, " 201 "current transmit buffer-to-buffer credit = %i).\n", 202 err->primitive_sequence_event_timeout_count, 203 err->elastic_buffer_overrun_error_count, 204 err->advertised_receive_b2b_credit, 205 err->current_receive_b2b_credit, 206 err->advertised_transmit_b2b_credit, 207 err->current_transmit_b2b_credit); 208 } 209 210 static void zfcp_fsf_link_down_info_eval(struct zfcp_fsf_req *req, u8 id, 211 struct fsf_link_down_info *link_down) 212 { 213 struct zfcp_adapter *adapter = req->adapter; 214 215 if (atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED) 216 return; 217 218 atomic_set_mask(ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status); 219 220 if (!link_down) 221 goto out; 222 223 switch (link_down->error_code) { 224 case FSF_PSQ_LINK_NO_LIGHT: 225 dev_warn(&req->adapter->ccw_device->dev, 226 "The local link is down: no light detected.\n"); 227 break; 228 case FSF_PSQ_LINK_WRAP_PLUG: 229 dev_warn(&req->adapter->ccw_device->dev, 230 "The local link is down: wrap plug detected.\n"); 231 break; 232 case FSF_PSQ_LINK_NO_FCP: 233 dev_warn(&req->adapter->ccw_device->dev, 234 "The local link is down: " 235 "adjacent node on link does not support FCP.\n"); 236 break; 237 case FSF_PSQ_LINK_FIRMWARE_UPDATE: 238 dev_warn(&req->adapter->ccw_device->dev, 239 "The local link is down: " 240 "firmware update in progress.\n"); 241 break; 242 case FSF_PSQ_LINK_INVALID_WWPN: 243 dev_warn(&req->adapter->ccw_device->dev, 244 "The local link is down: " 245 "duplicate or invalid WWPN detected.\n"); 246 break; 247 case FSF_PSQ_LINK_NO_NPIV_SUPPORT: 248 dev_warn(&req->adapter->ccw_device->dev, 249 "The local link is down: " 250 "no support for NPIV by Fabric.\n"); 251 break; 252 case FSF_PSQ_LINK_NO_FCP_RESOURCES: 253 dev_warn(&req->adapter->ccw_device->dev, 254 "The local link is down: " 255 "out of resource in FCP daughtercard.\n"); 256 break; 257 case FSF_PSQ_LINK_NO_FABRIC_RESOURCES: 258 dev_warn(&req->adapter->ccw_device->dev, 259 "The local link is down: " 260 "out of resource in Fabric.\n"); 261 break; 262 case FSF_PSQ_LINK_FABRIC_LOGIN_UNABLE: 263 dev_warn(&req->adapter->ccw_device->dev, 264 "The local link is down: " 265 "unable to login to Fabric.\n"); 266 break; 267 case FSF_PSQ_LINK_WWPN_ASSIGNMENT_CORRUPTED: 268 dev_warn(&req->adapter->ccw_device->dev, 269 "WWPN assignment file corrupted on adapter.\n"); 270 break; 271 case FSF_PSQ_LINK_MODE_TABLE_CURRUPTED: 272 dev_warn(&req->adapter->ccw_device->dev, 273 "Mode table corrupted on adapter.\n"); 274 break; 275 case FSF_PSQ_LINK_NO_WWPN_ASSIGNMENT: 276 dev_warn(&req->adapter->ccw_device->dev, 277 "No WWPN for assignment table on adapter.\n"); 278 break; 279 default: 280 dev_warn(&req->adapter->ccw_device->dev, 281 "The local link to adapter is down.\n"); 282 } 283 out: 284 zfcp_erp_adapter_failed(adapter, id, req); 285 } 286 287 static void zfcp_fsf_status_read_link_down(struct zfcp_fsf_req *req) 288 { 289 struct zfcp_adapter *adapter = req->adapter; 290 struct fsf_status_read_buffer *sr_buf = req->data; 291 struct fsf_link_down_info *ldi = 292 (struct fsf_link_down_info *) &sr_buf->payload; 293 294 switch (sr_buf->status_subtype) { 295 case FSF_STATUS_READ_SUB_NO_PHYSICAL_LINK: 296 dev_warn(&adapter->ccw_device->dev, 297 "Physical link is down.\n"); 298 zfcp_fsf_link_down_info_eval(req, 38, ldi); 299 break; 300 case FSF_STATUS_READ_SUB_FDISC_FAILED: 301 dev_warn(&adapter->ccw_device->dev, 302 "Local link is down " 303 "due to failed FDISC login.\n"); 304 zfcp_fsf_link_down_info_eval(req, 39, ldi); 305 break; 306 case FSF_STATUS_READ_SUB_FIRMWARE_UPDATE: 307 dev_warn(&adapter->ccw_device->dev, 308 "Local link is down " 309 "due to firmware update on adapter.\n"); 310 zfcp_fsf_link_down_info_eval(req, 40, NULL); 311 }; 312 } 313 314 static void zfcp_fsf_status_read_handler(struct zfcp_fsf_req *req) 315 { 316 struct zfcp_adapter *adapter = req->adapter; 317 struct fsf_status_read_buffer *sr_buf = req->data; 318 319 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { 320 zfcp_hba_dbf_event_fsf_unsol("dism", adapter, sr_buf); 321 mempool_free(sr_buf, adapter->pool.data_status_read); 322 zfcp_fsf_req_free(req); 323 return; 324 } 325 326 zfcp_hba_dbf_event_fsf_unsol("read", adapter, sr_buf); 327 328 switch (sr_buf->status_type) { 329 case FSF_STATUS_READ_PORT_CLOSED: 330 zfcp_fsf_status_read_port_closed(req); 331 break; 332 case FSF_STATUS_READ_INCOMING_ELS: 333 zfcp_fc_incoming_els(req); 334 break; 335 case FSF_STATUS_READ_SENSE_DATA_AVAIL: 336 break; 337 case FSF_STATUS_READ_BIT_ERROR_THRESHOLD: 338 zfcp_fsf_bit_error_threshold(req); 339 break; 340 case FSF_STATUS_READ_LINK_DOWN: 341 zfcp_fsf_status_read_link_down(req); 342 break; 343 case FSF_STATUS_READ_LINK_UP: 344 dev_info(&adapter->ccw_device->dev, 345 "Local link was replugged.\n"); 346 /* All ports should be marked as ready to run again */ 347 zfcp_erp_modify_adapter_status(adapter, 30, NULL, 348 ZFCP_STATUS_COMMON_RUNNING, 349 ZFCP_SET); 350 zfcp_erp_adapter_reopen(adapter, 351 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 352 ZFCP_STATUS_COMMON_ERP_FAILED, 353 102, req); 354 break; 355 case FSF_STATUS_READ_NOTIFICATION_LOST: 356 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_ACT_UPDATED) 357 zfcp_erp_adapter_access_changed(adapter, 135, req); 358 if (sr_buf->status_subtype & FSF_STATUS_READ_SUB_INCOMING_ELS) 359 schedule_work(&adapter->scan_work); 360 break; 361 case FSF_STATUS_READ_CFDC_UPDATED: 362 zfcp_erp_adapter_access_changed(adapter, 136, req); 363 break; 364 case FSF_STATUS_READ_FEATURE_UPDATE_ALERT: 365 adapter->adapter_features = sr_buf->payload.word[0]; 366 break; 367 } 368 369 mempool_free(sr_buf, adapter->pool.data_status_read); 370 zfcp_fsf_req_free(req); 371 372 atomic_inc(&adapter->stat_miss); 373 schedule_work(&adapter->stat_work); 374 } 375 376 static void zfcp_fsf_fsfstatus_qual_eval(struct zfcp_fsf_req *req) 377 { 378 switch (req->qtcb->header.fsf_status_qual.word[0]) { 379 case FSF_SQ_FCP_RSP_AVAILABLE: 380 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 381 case FSF_SQ_NO_RETRY_POSSIBLE: 382 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 383 return; 384 case FSF_SQ_COMMAND_ABORTED: 385 req->status |= ZFCP_STATUS_FSFREQ_ABORTED; 386 break; 387 case FSF_SQ_NO_RECOM: 388 dev_err(&req->adapter->ccw_device->dev, 389 "No recommendation could be given for a " 390 "problem on the adapter.\n"); 391 zfcp_erp_adapter_shutdown(req->adapter, 0, 121, req); 392 break; 393 } 394 /* all non-return stats set FSFREQ_ERROR*/ 395 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 396 } 397 398 static void zfcp_fsf_fsfstatus_eval(struct zfcp_fsf_req *req) 399 { 400 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) 401 return; 402 403 switch (req->qtcb->header.fsf_status) { 404 case FSF_UNKNOWN_COMMAND: 405 dev_err(&req->adapter->ccw_device->dev, 406 "Command issued by the device driver (0x%x) is " 407 "not known by the adapter.\n", 408 req->qtcb->header.fsf_command); 409 zfcp_erp_adapter_shutdown(req->adapter, 0, 120, req); 410 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 411 break; 412 case FSF_ADAPTER_STATUS_AVAILABLE: 413 zfcp_fsf_fsfstatus_qual_eval(req); 414 break; 415 } 416 } 417 418 static void zfcp_fsf_protstatus_eval(struct zfcp_fsf_req *req) 419 { 420 struct zfcp_adapter *adapter = req->adapter; 421 struct fsf_qtcb *qtcb = req->qtcb; 422 union fsf_prot_status_qual *psq = &qtcb->prefix.prot_status_qual; 423 424 zfcp_hba_dbf_event_fsf_response(req); 425 426 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED) { 427 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 428 ZFCP_STATUS_FSFREQ_RETRY; /* only for SCSI cmnds. */ 429 return; 430 } 431 432 switch (qtcb->prefix.prot_status) { 433 case FSF_PROT_GOOD: 434 case FSF_PROT_FSF_STATUS_PRESENTED: 435 return; 436 case FSF_PROT_QTCB_VERSION_ERROR: 437 dev_err(&adapter->ccw_device->dev, 438 "The QTCB version requested by zfcp (0x%x) is not " 439 "supported by the FCP adapter (lowest supported " 440 "0x%x, highest supported 0x%x).\n", 441 FSF_QTCB_CURRENT_VERSION, psq->word[0], 442 psq->word[1]); 443 zfcp_erp_adapter_shutdown(adapter, 0, 117, req); 444 break; 445 case FSF_PROT_ERROR_STATE: 446 case FSF_PROT_SEQ_NUMB_ERROR: 447 zfcp_erp_adapter_reopen(adapter, 0, 98, req); 448 req->status |= ZFCP_STATUS_FSFREQ_RETRY; 449 break; 450 case FSF_PROT_UNSUPP_QTCB_TYPE: 451 dev_err(&adapter->ccw_device->dev, 452 "Packet header type used by the device driver is " 453 "incompatible with that used on the adapter.\n"); 454 zfcp_erp_adapter_shutdown(adapter, 0, 118, req); 455 break; 456 case FSF_PROT_HOST_CONNECTION_INITIALIZING: 457 atomic_set_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT, 458 &adapter->status); 459 break; 460 case FSF_PROT_DUPLICATE_REQUEST_ID: 461 dev_err(&adapter->ccw_device->dev, 462 "The request identifier 0x%Lx is ambiguous.\n", 463 (unsigned long long)qtcb->bottom.support.req_handle); 464 zfcp_erp_adapter_shutdown(adapter, 0, 78, req); 465 break; 466 case FSF_PROT_LINK_DOWN: 467 zfcp_fsf_link_down_info_eval(req, 37, &psq->link_down_info); 468 /* FIXME: reopening adapter now? better wait for link up */ 469 zfcp_erp_adapter_reopen(adapter, 0, 79, req); 470 break; 471 case FSF_PROT_REEST_QUEUE: 472 /* All ports should be marked as ready to run again */ 473 zfcp_erp_modify_adapter_status(adapter, 28, NULL, 474 ZFCP_STATUS_COMMON_RUNNING, 475 ZFCP_SET); 476 zfcp_erp_adapter_reopen(adapter, 477 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED | 478 ZFCP_STATUS_COMMON_ERP_FAILED, 99, req); 479 break; 480 default: 481 dev_err(&adapter->ccw_device->dev, 482 "Transfer protocol status information" 483 "provided by the adapter (0x%x) " 484 "is not compatible with the device driver.\n", 485 qtcb->prefix.prot_status); 486 zfcp_erp_adapter_shutdown(adapter, 0, 119, req); 487 } 488 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 489 } 490 491 /** 492 * zfcp_fsf_req_complete - process completion of a FSF request 493 * @fsf_req: The FSF request that has been completed. 494 * 495 * When a request has been completed either from the FCP adapter, 496 * or it has been dismissed due to a queue shutdown, this function 497 * is called to process the completion status and trigger further 498 * events related to the FSF request. 499 */ 500 void zfcp_fsf_req_complete(struct zfcp_fsf_req *req) 501 { 502 if (unlikely(req->fsf_command == FSF_QTCB_UNSOLICITED_STATUS)) { 503 zfcp_fsf_status_read_handler(req); 504 return; 505 } 506 507 del_timer(&req->timer); 508 zfcp_fsf_protstatus_eval(req); 509 zfcp_fsf_fsfstatus_eval(req); 510 req->handler(req); 511 512 if (req->erp_action) 513 zfcp_erp_notify(req->erp_action, 0); 514 req->status |= ZFCP_STATUS_FSFREQ_COMPLETED; 515 516 if (likely(req->status & ZFCP_STATUS_FSFREQ_CLEANUP)) 517 zfcp_fsf_req_free(req); 518 else 519 /* notify initiator waiting for the requests completion */ 520 /* 521 * FIXME: Race! We must not access fsf_req here as it might have been 522 * cleaned up already due to the set ZFCP_STATUS_FSFREQ_COMPLETED 523 * flag. It's an improbable case. But, we have the same paranoia for 524 * the cleanup flag already. 525 * Might better be handled using complete()? 526 * (setting the flag and doing wakeup ought to be atomic 527 * with regard to checking the flag as long as waitqueue is 528 * part of the to be released structure) 529 */ 530 wake_up(&req->completion_wq); 531 } 532 533 static int zfcp_fsf_exchange_config_evaluate(struct zfcp_fsf_req *req) 534 { 535 struct fsf_qtcb_bottom_config *bottom; 536 struct zfcp_adapter *adapter = req->adapter; 537 struct Scsi_Host *shost = adapter->scsi_host; 538 539 bottom = &req->qtcb->bottom.config; 540 541 if (req->data) 542 memcpy(req->data, bottom, sizeof(*bottom)); 543 544 fc_host_node_name(shost) = bottom->nport_serv_param.wwnn; 545 fc_host_port_name(shost) = bottom->nport_serv_param.wwpn; 546 fc_host_port_id(shost) = bottom->s_id & ZFCP_DID_MASK; 547 fc_host_speed(shost) = bottom->fc_link_speed; 548 fc_host_supported_classes(shost) = FC_COS_CLASS2 | FC_COS_CLASS3; 549 550 adapter->hydra_version = bottom->adapter_type; 551 adapter->timer_ticks = bottom->timer_interval; 552 553 if (fc_host_permanent_port_name(shost) == -1) 554 fc_host_permanent_port_name(shost) = fc_host_port_name(shost); 555 556 switch (bottom->fc_topology) { 557 case FSF_TOPO_P2P: 558 adapter->peer_d_id = bottom->peer_d_id & ZFCP_DID_MASK; 559 adapter->peer_wwpn = bottom->plogi_payload.wwpn; 560 adapter->peer_wwnn = bottom->plogi_payload.wwnn; 561 fc_host_port_type(shost) = FC_PORTTYPE_PTP; 562 if (req->erp_action) 563 dev_info(&adapter->ccw_device->dev, 564 "Point-to-Point fibrechannel " 565 "configuration detected.\n"); 566 break; 567 case FSF_TOPO_FABRIC: 568 fc_host_port_type(shost) = FC_PORTTYPE_NPORT; 569 if (req->erp_action) 570 dev_info(&adapter->ccw_device->dev, 571 "Switched fabric fibrechannel " 572 "network detected.\n"); 573 break; 574 case FSF_TOPO_AL: 575 fc_host_port_type(shost) = FC_PORTTYPE_NLPORT; 576 dev_err(&adapter->ccw_device->dev, 577 "Unsupported arbitrated loop fibrechannel " 578 "topology detected, shutting down " 579 "adapter.\n"); 580 zfcp_erp_adapter_shutdown(adapter, 0, 127, req); 581 return -EIO; 582 default: 583 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 584 dev_err(&adapter->ccw_device->dev, 585 "The fibrechannel topology reported by the" 586 " adapter is not known by the zfcp driver," 587 " shutting down adapter.\n"); 588 zfcp_erp_adapter_shutdown(adapter, 0, 128, req); 589 return -EIO; 590 } 591 592 return 0; 593 } 594 595 static void zfcp_fsf_exchange_config_data_handler(struct zfcp_fsf_req *req) 596 { 597 struct zfcp_adapter *adapter = req->adapter; 598 struct fsf_qtcb *qtcb = req->qtcb; 599 struct fsf_qtcb_bottom_config *bottom = &qtcb->bottom.config; 600 struct Scsi_Host *shost = adapter->scsi_host; 601 602 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 603 return; 604 605 adapter->fsf_lic_version = bottom->lic_version; 606 adapter->adapter_features = bottom->adapter_features; 607 adapter->connection_features = bottom->connection_features; 608 adapter->peer_wwpn = 0; 609 adapter->peer_wwnn = 0; 610 adapter->peer_d_id = 0; 611 612 switch (qtcb->header.fsf_status) { 613 case FSF_GOOD: 614 if (zfcp_fsf_exchange_config_evaluate(req)) 615 return; 616 617 if (bottom->max_qtcb_size < sizeof(struct fsf_qtcb)) { 618 dev_err(&adapter->ccw_device->dev, 619 "Maximum QTCB size (%d bytes) allowed by " 620 "the adapter is lower than the minimum " 621 "required by the driver (%ld bytes).\n", 622 bottom->max_qtcb_size, 623 sizeof(struct fsf_qtcb)); 624 zfcp_erp_adapter_shutdown(adapter, 0, 129, req); 625 return; 626 } 627 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 628 &adapter->status); 629 break; 630 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE: 631 fc_host_node_name(shost) = 0; 632 fc_host_port_name(shost) = 0; 633 fc_host_port_id(shost) = 0; 634 fc_host_speed(shost) = FC_PORTSPEED_UNKNOWN; 635 fc_host_port_type(shost) = FC_PORTTYPE_UNKNOWN; 636 adapter->hydra_version = 0; 637 638 atomic_set_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, 639 &adapter->status); 640 641 zfcp_fsf_link_down_info_eval(req, 42, 642 &qtcb->header.fsf_status_qual.link_down_info); 643 break; 644 default: 645 zfcp_erp_adapter_shutdown(adapter, 0, 130, req); 646 return; 647 } 648 649 if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) { 650 adapter->hardware_version = bottom->hardware_version; 651 memcpy(fc_host_serial_number(shost), bottom->serial_number, 652 min(FC_SERIAL_NUMBER_SIZE, 17)); 653 EBCASC(fc_host_serial_number(shost), 654 min(FC_SERIAL_NUMBER_SIZE, 17)); 655 } 656 657 if (FSF_QTCB_CURRENT_VERSION < bottom->low_qtcb_version) { 658 dev_err(&adapter->ccw_device->dev, 659 "The adapter only supports newer control block " 660 "versions, try updated device driver.\n"); 661 zfcp_erp_adapter_shutdown(adapter, 0, 125, req); 662 return; 663 } 664 if (FSF_QTCB_CURRENT_VERSION > bottom->high_qtcb_version) { 665 dev_err(&adapter->ccw_device->dev, 666 "The adapter only supports older control block " 667 "versions, consider a microcode upgrade.\n"); 668 zfcp_erp_adapter_shutdown(adapter, 0, 126, req); 669 } 670 } 671 672 static void zfcp_fsf_exchange_port_evaluate(struct zfcp_fsf_req *req) 673 { 674 struct zfcp_adapter *adapter = req->adapter; 675 struct fsf_qtcb_bottom_port *bottom = &req->qtcb->bottom.port; 676 struct Scsi_Host *shost = adapter->scsi_host; 677 678 if (req->data) 679 memcpy(req->data, bottom, sizeof(*bottom)); 680 681 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE) 682 fc_host_permanent_port_name(shost) = bottom->wwpn; 683 else 684 fc_host_permanent_port_name(shost) = fc_host_port_name(shost); 685 fc_host_maxframe_size(shost) = bottom->maximum_frame_size; 686 fc_host_supported_speeds(shost) = bottom->supported_speed; 687 } 688 689 static void zfcp_fsf_exchange_port_data_handler(struct zfcp_fsf_req *req) 690 { 691 struct zfcp_adapter *adapter = req->adapter; 692 struct fsf_qtcb *qtcb = req->qtcb; 693 694 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 695 return; 696 697 switch (qtcb->header.fsf_status) { 698 case FSF_GOOD: 699 zfcp_fsf_exchange_port_evaluate(req); 700 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); 701 break; 702 case FSF_EXCHANGE_CONFIG_DATA_INCOMPLETE: 703 zfcp_fsf_exchange_port_evaluate(req); 704 atomic_set_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status); 705 zfcp_fsf_link_down_info_eval(req, 43, 706 &qtcb->header.fsf_status_qual.link_down_info); 707 break; 708 } 709 } 710 711 static int zfcp_fsf_sbal_check(struct zfcp_qdio_queue *queue) 712 { 713 spin_lock(&queue->lock); 714 if (atomic_read(&queue->count)) 715 return 1; 716 spin_unlock(&queue->lock); 717 return 0; 718 } 719 720 static int zfcp_fsf_req_sbal_get(struct zfcp_adapter *adapter) 721 { 722 long ret; 723 struct zfcp_qdio_queue *req_q = &adapter->req_q; 724 725 spin_unlock(&req_q->lock); 726 ret = wait_event_interruptible_timeout(adapter->request_wq, 727 zfcp_fsf_sbal_check(req_q), 5 * HZ); 728 if (ret > 0) 729 return 0; 730 731 spin_lock(&req_q->lock); 732 return -EIO; 733 } 734 735 static struct zfcp_fsf_req *zfcp_fsf_alloc_noqtcb(mempool_t *pool) 736 { 737 struct zfcp_fsf_req *req; 738 req = mempool_alloc(pool, GFP_ATOMIC); 739 if (!req) 740 return NULL; 741 memset(req, 0, sizeof(*req)); 742 return req; 743 } 744 745 static struct zfcp_fsf_req *zfcp_fsf_alloc_qtcb(mempool_t *pool) 746 { 747 struct zfcp_fsf_req_qtcb *qtcb; 748 749 if (likely(pool)) 750 qtcb = mempool_alloc(pool, GFP_ATOMIC); 751 else 752 qtcb = kmem_cache_alloc(zfcp_data.fsf_req_qtcb_cache, 753 GFP_ATOMIC); 754 if (unlikely(!qtcb)) 755 return NULL; 756 757 memset(qtcb, 0, sizeof(*qtcb)); 758 qtcb->fsf_req.qtcb = &qtcb->qtcb; 759 qtcb->fsf_req.pool = pool; 760 761 return &qtcb->fsf_req; 762 } 763 764 static struct zfcp_fsf_req *zfcp_fsf_req_create(struct zfcp_adapter *adapter, 765 u32 fsf_cmd, int req_flags, 766 mempool_t *pool) 767 { 768 volatile struct qdio_buffer_element *sbale; 769 770 struct zfcp_fsf_req *req; 771 struct zfcp_qdio_queue *req_q = &adapter->req_q; 772 773 if (req_flags & ZFCP_REQ_NO_QTCB) 774 req = zfcp_fsf_alloc_noqtcb(pool); 775 else 776 req = zfcp_fsf_alloc_qtcb(pool); 777 778 if (unlikely(!req)) 779 return ERR_PTR(-EIO); 780 781 if (adapter->req_no == 0) 782 adapter->req_no++; 783 784 INIT_LIST_HEAD(&req->list); 785 init_timer(&req->timer); 786 init_waitqueue_head(&req->completion_wq); 787 788 req->adapter = adapter; 789 req->fsf_command = fsf_cmd; 790 req->req_id = adapter->req_no++; 791 req->sbal_number = 1; 792 req->sbal_first = req_q->first; 793 req->sbal_last = req_q->first; 794 req->sbale_curr = 1; 795 796 sbale = zfcp_qdio_sbale_req(req); 797 sbale[0].addr = (void *) req->req_id; 798 sbale[0].flags |= SBAL_FLAGS0_COMMAND; 799 800 if (likely(req->qtcb)) { 801 req->qtcb->prefix.req_seq_no = req->adapter->fsf_req_seq_no; 802 req->qtcb->prefix.req_id = req->req_id; 803 req->qtcb->prefix.ulp_info = 26; 804 req->qtcb->prefix.qtcb_type = fsf_qtcb_type[req->fsf_command]; 805 req->qtcb->prefix.qtcb_version = FSF_QTCB_CURRENT_VERSION; 806 req->qtcb->header.req_handle = req->req_id; 807 req->qtcb->header.fsf_command = req->fsf_command; 808 req->seq_no = adapter->fsf_req_seq_no; 809 req->qtcb->prefix.req_seq_no = adapter->fsf_req_seq_no; 810 sbale[1].addr = (void *) req->qtcb; 811 sbale[1].length = sizeof(struct fsf_qtcb); 812 } 813 814 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_QDIOUP)) { 815 zfcp_fsf_req_free(req); 816 return ERR_PTR(-EIO); 817 } 818 819 if (likely(req_flags & ZFCP_REQ_AUTO_CLEANUP)) 820 req->status |= ZFCP_STATUS_FSFREQ_CLEANUP; 821 822 return req; 823 } 824 825 static int zfcp_fsf_req_send(struct zfcp_fsf_req *req) 826 { 827 struct zfcp_adapter *adapter = req->adapter; 828 struct zfcp_qdio_queue *req_q = &adapter->req_q; 829 int idx; 830 831 /* put allocated FSF request into hash table */ 832 spin_lock(&adapter->req_list_lock); 833 idx = zfcp_reqlist_hash(req->req_id); 834 list_add_tail(&req->list, &adapter->req_list[idx]); 835 spin_unlock(&adapter->req_list_lock); 836 837 req->issued = get_clock(); 838 if (zfcp_qdio_send(req)) { 839 /* Queues are down..... */ 840 del_timer(&req->timer); 841 spin_lock(&adapter->req_list_lock); 842 zfcp_reqlist_remove(adapter, req); 843 spin_unlock(&adapter->req_list_lock); 844 /* undo changes in request queue made for this request */ 845 atomic_add(req->sbal_number, &req_q->count); 846 req_q->first -= req->sbal_number; 847 req_q->first += QDIO_MAX_BUFFERS_PER_Q; 848 req_q->first %= QDIO_MAX_BUFFERS_PER_Q; /* wrap */ 849 zfcp_erp_adapter_reopen(adapter, 0, 116, req); 850 return -EIO; 851 } 852 853 /* Don't increase for unsolicited status */ 854 if (req->qtcb) 855 adapter->fsf_req_seq_no++; 856 857 return 0; 858 } 859 860 /** 861 * zfcp_fsf_status_read - send status read request 862 * @adapter: pointer to struct zfcp_adapter 863 * @req_flags: request flags 864 * Returns: 0 on success, ERROR otherwise 865 */ 866 int zfcp_fsf_status_read(struct zfcp_adapter *adapter) 867 { 868 struct zfcp_fsf_req *req; 869 struct fsf_status_read_buffer *sr_buf; 870 volatile struct qdio_buffer_element *sbale; 871 int retval = -EIO; 872 873 spin_lock(&adapter->req_q.lock); 874 if (zfcp_fsf_req_sbal_get(adapter)) 875 goto out; 876 877 req = zfcp_fsf_req_create(adapter, FSF_QTCB_UNSOLICITED_STATUS, 878 ZFCP_REQ_NO_QTCB, 879 adapter->pool.fsf_req_status_read); 880 if (unlikely(IS_ERR(req))) { 881 retval = PTR_ERR(req); 882 goto out; 883 } 884 885 sbale = zfcp_qdio_sbale_req(req); 886 sbale[0].flags |= SBAL_FLAGS0_TYPE_STATUS; 887 sbale[2].flags |= SBAL_FLAGS_LAST_ENTRY; 888 req->sbale_curr = 2; 889 890 sr_buf = mempool_alloc(adapter->pool.data_status_read, GFP_ATOMIC); 891 if (!sr_buf) { 892 retval = -ENOMEM; 893 goto failed_buf; 894 } 895 memset(sr_buf, 0, sizeof(*sr_buf)); 896 req->data = sr_buf; 897 sbale = zfcp_qdio_sbale_curr(req); 898 sbale->addr = (void *) sr_buf; 899 sbale->length = sizeof(*sr_buf); 900 901 retval = zfcp_fsf_req_send(req); 902 if (retval) 903 goto failed_req_send; 904 905 goto out; 906 907 failed_req_send: 908 mempool_free(sr_buf, adapter->pool.data_status_read); 909 failed_buf: 910 zfcp_fsf_req_free(req); 911 zfcp_hba_dbf_event_fsf_unsol("fail", adapter, NULL); 912 out: 913 spin_unlock(&adapter->req_q.lock); 914 return retval; 915 } 916 917 static void zfcp_fsf_abort_fcp_command_handler(struct zfcp_fsf_req *req) 918 { 919 struct zfcp_unit *unit = req->data; 920 union fsf_status_qual *fsq = &req->qtcb->header.fsf_status_qual; 921 922 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 923 return; 924 925 switch (req->qtcb->header.fsf_status) { 926 case FSF_PORT_HANDLE_NOT_VALID: 927 if (fsq->word[0] == fsq->word[1]) { 928 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 104, 929 req); 930 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 931 } 932 break; 933 case FSF_LUN_HANDLE_NOT_VALID: 934 if (fsq->word[0] == fsq->word[1]) { 935 zfcp_erp_port_reopen(unit->port, 0, 105, req); 936 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 937 } 938 break; 939 case FSF_FCP_COMMAND_DOES_NOT_EXIST: 940 req->status |= ZFCP_STATUS_FSFREQ_ABORTNOTNEEDED; 941 break; 942 case FSF_PORT_BOXED: 943 zfcp_erp_port_boxed(unit->port, 47, req); 944 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 945 ZFCP_STATUS_FSFREQ_RETRY; 946 break; 947 case FSF_LUN_BOXED: 948 zfcp_erp_unit_boxed(unit, 48, req); 949 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 950 ZFCP_STATUS_FSFREQ_RETRY; 951 break; 952 case FSF_ADAPTER_STATUS_AVAILABLE: 953 switch (fsq->word[0]) { 954 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 955 zfcp_test_link(unit->port); 956 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 957 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 958 break; 959 } 960 break; 961 case FSF_GOOD: 962 req->status |= ZFCP_STATUS_FSFREQ_ABORTSUCCEEDED; 963 break; 964 } 965 } 966 967 /** 968 * zfcp_fsf_abort_fcp_command - abort running SCSI command 969 * @old_req_id: unsigned long 970 * @adapter: pointer to struct zfcp_adapter 971 * @unit: pointer to struct zfcp_unit 972 * @req_flags: integer specifying the request flags 973 * Returns: pointer to struct zfcp_fsf_req 974 * 975 * FIXME(design): should be watched by a timeout !!! 976 */ 977 978 struct zfcp_fsf_req *zfcp_fsf_abort_fcp_command(unsigned long old_req_id, 979 struct zfcp_adapter *adapter, 980 struct zfcp_unit *unit, 981 int req_flags) 982 { 983 volatile struct qdio_buffer_element *sbale; 984 struct zfcp_fsf_req *req = NULL; 985 986 spin_lock(&adapter->req_q.lock); 987 if (!atomic_read(&adapter->req_q.count)) 988 goto out; 989 req = zfcp_fsf_req_create(adapter, FSF_QTCB_ABORT_FCP_CMND, 990 req_flags, adapter->pool.fsf_req_abort); 991 if (unlikely(IS_ERR(req))) 992 goto out; 993 994 if (unlikely(!(atomic_read(&unit->status) & 995 ZFCP_STATUS_COMMON_UNBLOCKED))) 996 goto out_error_free; 997 998 sbale = zfcp_qdio_sbale_req(req); 999 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1000 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1001 1002 req->data = unit; 1003 req->handler = zfcp_fsf_abort_fcp_command_handler; 1004 req->qtcb->header.lun_handle = unit->handle; 1005 req->qtcb->header.port_handle = unit->port->handle; 1006 req->qtcb->bottom.support.req_handle = (u64) old_req_id; 1007 1008 zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT); 1009 if (!zfcp_fsf_req_send(req)) 1010 goto out; 1011 1012 out_error_free: 1013 zfcp_fsf_req_free(req); 1014 req = NULL; 1015 out: 1016 spin_unlock(&adapter->req_q.lock); 1017 return req; 1018 } 1019 1020 static void zfcp_fsf_send_ct_handler(struct zfcp_fsf_req *req) 1021 { 1022 struct zfcp_adapter *adapter = req->adapter; 1023 struct zfcp_send_ct *send_ct = req->data; 1024 struct zfcp_port *port = send_ct->port; 1025 struct fsf_qtcb_header *header = &req->qtcb->header; 1026 1027 send_ct->status = -EINVAL; 1028 1029 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1030 goto skip_fsfstatus; 1031 1032 switch (header->fsf_status) { 1033 case FSF_GOOD: 1034 zfcp_san_dbf_event_ct_response(req); 1035 send_ct->status = 0; 1036 break; 1037 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 1038 zfcp_fsf_class_not_supp(req); 1039 break; 1040 case FSF_ADAPTER_STATUS_AVAILABLE: 1041 switch (header->fsf_status_qual.word[0]){ 1042 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1043 zfcp_test_link(port); 1044 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1045 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1046 break; 1047 } 1048 break; 1049 case FSF_ACCESS_DENIED: 1050 zfcp_fsf_access_denied_port(req, port); 1051 break; 1052 case FSF_PORT_BOXED: 1053 zfcp_erp_port_boxed(port, 49, req); 1054 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 1055 ZFCP_STATUS_FSFREQ_RETRY; 1056 break; 1057 case FSF_PORT_HANDLE_NOT_VALID: 1058 zfcp_erp_adapter_reopen(adapter, 0, 106, req); 1059 case FSF_GENERIC_COMMAND_REJECTED: 1060 case FSF_PAYLOAD_SIZE_MISMATCH: 1061 case FSF_REQUEST_SIZE_TOO_LARGE: 1062 case FSF_RESPONSE_SIZE_TOO_LARGE: 1063 case FSF_SBAL_MISMATCH: 1064 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1065 break; 1066 } 1067 1068 skip_fsfstatus: 1069 if (send_ct->handler) 1070 send_ct->handler(send_ct->handler_data); 1071 } 1072 1073 static int zfcp_fsf_setup_sbals(struct zfcp_fsf_req *req, 1074 struct scatterlist *sg_req, 1075 struct scatterlist *sg_resp, int max_sbals) 1076 { 1077 int bytes; 1078 1079 bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ, 1080 sg_req, max_sbals); 1081 if (bytes <= 0) 1082 return -ENOMEM; 1083 req->qtcb->bottom.support.req_buf_length = bytes; 1084 req->sbale_curr = ZFCP_LAST_SBALE_PER_SBAL; 1085 1086 bytes = zfcp_qdio_sbals_from_sg(req, SBAL_FLAGS0_TYPE_WRITE_READ, 1087 sg_resp, max_sbals); 1088 if (bytes <= 0) 1089 return -ENOMEM; 1090 req->qtcb->bottom.support.resp_buf_length = bytes; 1091 1092 return 0; 1093 } 1094 1095 /** 1096 * zfcp_fsf_send_ct - initiate a Generic Service request (FC-GS) 1097 * @ct: pointer to struct zfcp_send_ct with data for request 1098 * @pool: if non-null this mempool is used to allocate struct zfcp_fsf_req 1099 * @erp_action: if non-null the Generic Service request sent within ERP 1100 */ 1101 int zfcp_fsf_send_ct(struct zfcp_send_ct *ct, mempool_t *pool, 1102 struct zfcp_erp_action *erp_action) 1103 { 1104 struct zfcp_port *port = ct->port; 1105 struct zfcp_adapter *adapter = port->adapter; 1106 struct zfcp_fsf_req *req; 1107 int ret = -EIO; 1108 1109 spin_lock(&adapter->req_q.lock); 1110 if (zfcp_fsf_req_sbal_get(adapter)) 1111 goto out; 1112 1113 req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_GENERIC, 1114 ZFCP_REQ_AUTO_CLEANUP, pool); 1115 if (unlikely(IS_ERR(req))) { 1116 ret = PTR_ERR(req); 1117 goto out; 1118 } 1119 1120 ret = zfcp_fsf_setup_sbals(req, ct->req, ct->resp, 1121 FSF_MAX_SBALS_PER_REQ); 1122 if (ret) 1123 goto failed_send; 1124 1125 req->handler = zfcp_fsf_send_ct_handler; 1126 req->qtcb->header.port_handle = port->handle; 1127 req->qtcb->bottom.support.service_class = FSF_CLASS_3; 1128 req->qtcb->bottom.support.timeout = ct->timeout; 1129 req->data = ct; 1130 1131 zfcp_san_dbf_event_ct_request(req); 1132 1133 if (erp_action) { 1134 erp_action->fsf_req = req; 1135 req->erp_action = erp_action; 1136 zfcp_fsf_start_erp_timer(req); 1137 } else 1138 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 1139 1140 ret = zfcp_fsf_req_send(req); 1141 if (ret) 1142 goto failed_send; 1143 1144 goto out; 1145 1146 failed_send: 1147 zfcp_fsf_req_free(req); 1148 if (erp_action) 1149 erp_action->fsf_req = NULL; 1150 out: 1151 spin_unlock(&adapter->req_q.lock); 1152 return ret; 1153 } 1154 1155 static void zfcp_fsf_send_els_handler(struct zfcp_fsf_req *req) 1156 { 1157 struct zfcp_send_els *send_els = req->data; 1158 struct zfcp_port *port = send_els->port; 1159 struct fsf_qtcb_header *header = &req->qtcb->header; 1160 1161 send_els->status = -EINVAL; 1162 1163 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1164 goto skip_fsfstatus; 1165 1166 switch (header->fsf_status) { 1167 case FSF_GOOD: 1168 zfcp_san_dbf_event_els_response(req); 1169 send_els->status = 0; 1170 break; 1171 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 1172 zfcp_fsf_class_not_supp(req); 1173 break; 1174 case FSF_ADAPTER_STATUS_AVAILABLE: 1175 switch (header->fsf_status_qual.word[0]){ 1176 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1177 if (port && (send_els->ls_code != ZFCP_LS_ADISC)) 1178 zfcp_test_link(port); 1179 /*fall through */ 1180 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1181 case FSF_SQ_RETRY_IF_POSSIBLE: 1182 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1183 break; 1184 } 1185 break; 1186 case FSF_ELS_COMMAND_REJECTED: 1187 case FSF_PAYLOAD_SIZE_MISMATCH: 1188 case FSF_REQUEST_SIZE_TOO_LARGE: 1189 case FSF_RESPONSE_SIZE_TOO_LARGE: 1190 break; 1191 case FSF_ACCESS_DENIED: 1192 zfcp_fsf_access_denied_port(req, port); 1193 break; 1194 case FSF_SBAL_MISMATCH: 1195 /* should never occure, avoided in zfcp_fsf_send_els */ 1196 /* fall through */ 1197 default: 1198 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1199 break; 1200 } 1201 skip_fsfstatus: 1202 if (send_els->handler) 1203 send_els->handler(send_els->handler_data); 1204 } 1205 1206 /** 1207 * zfcp_fsf_send_els - initiate an ELS command (FC-FS) 1208 * @els: pointer to struct zfcp_send_els with data for the command 1209 */ 1210 int zfcp_fsf_send_els(struct zfcp_send_els *els) 1211 { 1212 struct zfcp_fsf_req *req; 1213 struct zfcp_adapter *adapter = els->adapter; 1214 struct fsf_qtcb_bottom_support *bottom; 1215 int ret = -EIO; 1216 1217 if (unlikely(!(atomic_read(&els->port->status) & 1218 ZFCP_STATUS_COMMON_UNBLOCKED))) 1219 return -EBUSY; 1220 1221 spin_lock(&adapter->req_q.lock); 1222 if (!atomic_read(&adapter->req_q.count)) 1223 goto out; 1224 req = zfcp_fsf_req_create(adapter, FSF_QTCB_SEND_ELS, 1225 ZFCP_REQ_AUTO_CLEANUP, NULL); 1226 if (unlikely(IS_ERR(req))) { 1227 ret = PTR_ERR(req); 1228 goto out; 1229 } 1230 1231 ret = zfcp_fsf_setup_sbals(req, els->req, els->resp, 1232 FSF_MAX_SBALS_PER_ELS_REQ); 1233 if (ret) 1234 goto failed_send; 1235 1236 bottom = &req->qtcb->bottom.support; 1237 req->handler = zfcp_fsf_send_els_handler; 1238 bottom->d_id = els->d_id; 1239 bottom->service_class = FSF_CLASS_3; 1240 bottom->timeout = 2 * R_A_TOV; 1241 req->data = els; 1242 1243 zfcp_san_dbf_event_els_request(req); 1244 1245 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 1246 ret = zfcp_fsf_req_send(req); 1247 if (ret) 1248 goto failed_send; 1249 1250 goto out; 1251 1252 failed_send: 1253 zfcp_fsf_req_free(req); 1254 out: 1255 spin_unlock(&adapter->req_q.lock); 1256 return ret; 1257 } 1258 1259 int zfcp_fsf_exchange_config_data(struct zfcp_erp_action *erp_action) 1260 { 1261 volatile struct qdio_buffer_element *sbale; 1262 struct zfcp_fsf_req *req; 1263 struct zfcp_adapter *adapter = erp_action->adapter; 1264 int retval = -EIO; 1265 1266 spin_lock(&adapter->req_q.lock); 1267 if (!atomic_read(&adapter->req_q.count)) 1268 goto out; 1269 req = zfcp_fsf_req_create(adapter, 1270 FSF_QTCB_EXCHANGE_CONFIG_DATA, 1271 ZFCP_REQ_AUTO_CLEANUP, 1272 adapter->pool.fsf_req_erp); 1273 if (unlikely(IS_ERR(req))) { 1274 retval = PTR_ERR(req); 1275 goto out; 1276 } 1277 1278 sbale = zfcp_qdio_sbale_req(req); 1279 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1280 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1281 1282 req->qtcb->bottom.config.feature_selection = 1283 FSF_FEATURE_CFDC | 1284 FSF_FEATURE_LUN_SHARING | 1285 FSF_FEATURE_NOTIFICATION_LOST | 1286 FSF_FEATURE_UPDATE_ALERT; 1287 req->erp_action = erp_action; 1288 req->handler = zfcp_fsf_exchange_config_data_handler; 1289 erp_action->fsf_req = req; 1290 1291 zfcp_fsf_start_erp_timer(req); 1292 retval = zfcp_fsf_req_send(req); 1293 if (retval) { 1294 zfcp_fsf_req_free(req); 1295 erp_action->fsf_req = NULL; 1296 } 1297 out: 1298 spin_unlock(&adapter->req_q.lock); 1299 return retval; 1300 } 1301 1302 int zfcp_fsf_exchange_config_data_sync(struct zfcp_adapter *adapter, 1303 struct fsf_qtcb_bottom_config *data) 1304 { 1305 volatile struct qdio_buffer_element *sbale; 1306 struct zfcp_fsf_req *req = NULL; 1307 int retval = -EIO; 1308 1309 spin_lock(&adapter->req_q.lock); 1310 if (zfcp_fsf_req_sbal_get(adapter)) 1311 goto out; 1312 1313 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_CONFIG_DATA, 1314 0, NULL); 1315 if (unlikely(IS_ERR(req))) { 1316 retval = PTR_ERR(req); 1317 goto out; 1318 } 1319 1320 sbale = zfcp_qdio_sbale_req(req); 1321 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1322 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1323 req->handler = zfcp_fsf_exchange_config_data_handler; 1324 1325 req->qtcb->bottom.config.feature_selection = 1326 FSF_FEATURE_CFDC | 1327 FSF_FEATURE_LUN_SHARING | 1328 FSF_FEATURE_NOTIFICATION_LOST | 1329 FSF_FEATURE_UPDATE_ALERT; 1330 1331 if (data) 1332 req->data = data; 1333 1334 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 1335 retval = zfcp_fsf_req_send(req); 1336 out: 1337 spin_unlock(&adapter->req_q.lock); 1338 if (!retval) 1339 wait_event(req->completion_wq, 1340 req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 1341 1342 zfcp_fsf_req_free(req); 1343 1344 return retval; 1345 } 1346 1347 /** 1348 * zfcp_fsf_exchange_port_data - request information about local port 1349 * @erp_action: ERP action for the adapter for which port data is requested 1350 * Returns: 0 on success, error otherwise 1351 */ 1352 int zfcp_fsf_exchange_port_data(struct zfcp_erp_action *erp_action) 1353 { 1354 volatile struct qdio_buffer_element *sbale; 1355 struct zfcp_fsf_req *req; 1356 struct zfcp_adapter *adapter = erp_action->adapter; 1357 int retval = -EIO; 1358 1359 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT)) 1360 return -EOPNOTSUPP; 1361 1362 spin_lock(&adapter->req_q.lock); 1363 if (!atomic_read(&adapter->req_q.count)) 1364 goto out; 1365 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 1366 ZFCP_REQ_AUTO_CLEANUP, 1367 adapter->pool.fsf_req_erp); 1368 if (unlikely(IS_ERR(req))) { 1369 retval = PTR_ERR(req); 1370 goto out; 1371 } 1372 1373 sbale = zfcp_qdio_sbale_req(req); 1374 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1375 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1376 1377 req->handler = zfcp_fsf_exchange_port_data_handler; 1378 req->erp_action = erp_action; 1379 erp_action->fsf_req = req; 1380 1381 zfcp_fsf_start_erp_timer(req); 1382 retval = zfcp_fsf_req_send(req); 1383 if (retval) { 1384 zfcp_fsf_req_free(req); 1385 erp_action->fsf_req = NULL; 1386 } 1387 out: 1388 spin_unlock(&adapter->req_q.lock); 1389 return retval; 1390 } 1391 1392 /** 1393 * zfcp_fsf_exchange_port_data_sync - request information about local port 1394 * @adapter: pointer to struct zfcp_adapter 1395 * @data: pointer to struct fsf_qtcb_bottom_port 1396 * Returns: 0 on success, error otherwise 1397 */ 1398 int zfcp_fsf_exchange_port_data_sync(struct zfcp_adapter *adapter, 1399 struct fsf_qtcb_bottom_port *data) 1400 { 1401 volatile struct qdio_buffer_element *sbale; 1402 struct zfcp_fsf_req *req = NULL; 1403 int retval = -EIO; 1404 1405 if (!(adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT)) 1406 return -EOPNOTSUPP; 1407 1408 spin_lock(&adapter->req_q.lock); 1409 if (!atomic_read(&adapter->req_q.count)) 1410 goto out; 1411 1412 req = zfcp_fsf_req_create(adapter, FSF_QTCB_EXCHANGE_PORT_DATA, 0, 1413 NULL); 1414 if (unlikely(IS_ERR(req))) { 1415 retval = PTR_ERR(req); 1416 goto out; 1417 } 1418 1419 if (data) 1420 req->data = data; 1421 1422 sbale = zfcp_qdio_sbale_req(req); 1423 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1424 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1425 1426 req->handler = zfcp_fsf_exchange_port_data_handler; 1427 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 1428 retval = zfcp_fsf_req_send(req); 1429 out: 1430 spin_unlock(&adapter->req_q.lock); 1431 if (!retval) 1432 wait_event(req->completion_wq, 1433 req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 1434 zfcp_fsf_req_free(req); 1435 1436 return retval; 1437 } 1438 1439 static void zfcp_fsf_open_port_handler(struct zfcp_fsf_req *req) 1440 { 1441 struct zfcp_port *port = req->data; 1442 struct fsf_qtcb_header *header = &req->qtcb->header; 1443 struct fsf_plogi *plogi; 1444 1445 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1446 goto skip_fsfstatus; 1447 1448 switch (header->fsf_status) { 1449 case FSF_PORT_ALREADY_OPEN: 1450 break; 1451 case FSF_ACCESS_DENIED: 1452 zfcp_fsf_access_denied_port(req, port); 1453 break; 1454 case FSF_MAXIMUM_NUMBER_OF_PORTS_EXCEEDED: 1455 dev_warn(&req->adapter->ccw_device->dev, 1456 "The adapter is out of resources. The remote port " 1457 "0x%016Lx could not be opened, disabling it.\n", 1458 port->wwpn); 1459 zfcp_erp_port_failed(port, 31, req); 1460 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1461 break; 1462 case FSF_ADAPTER_STATUS_AVAILABLE: 1463 switch (header->fsf_status_qual.word[0]) { 1464 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1465 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1466 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1467 break; 1468 case FSF_SQ_NO_RETRY_POSSIBLE: 1469 dev_warn(&req->adapter->ccw_device->dev, 1470 "The remote port 0x%016Lx could not be " 1471 "opened. Disabling it.\n", port->wwpn); 1472 zfcp_erp_port_failed(port, 32, req); 1473 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1474 break; 1475 } 1476 break; 1477 case FSF_GOOD: 1478 port->handle = header->port_handle; 1479 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN | 1480 ZFCP_STATUS_PORT_PHYS_OPEN, &port->status); 1481 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | 1482 ZFCP_STATUS_COMMON_ACCESS_BOXED, 1483 &port->status); 1484 /* check whether D_ID has changed during open */ 1485 /* 1486 * FIXME: This check is not airtight, as the FCP channel does 1487 * not monitor closures of target port connections caused on 1488 * the remote side. Thus, they might miss out on invalidating 1489 * locally cached WWPNs (and other N_Port parameters) of gone 1490 * target ports. So, our heroic attempt to make things safe 1491 * could be undermined by 'open port' response data tagged with 1492 * obsolete WWPNs. Another reason to monitor potential 1493 * connection closures ourself at least (by interpreting 1494 * incoming ELS' and unsolicited status). It just crosses my 1495 * mind that one should be able to cross-check by means of 1496 * another GID_PN straight after a port has been opened. 1497 * Alternately, an ADISC/PDISC ELS should suffice, as well. 1498 */ 1499 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN) 1500 break; 1501 1502 plogi = (struct fsf_plogi *) req->qtcb->bottom.support.els; 1503 if (req->qtcb->bottom.support.els1_length >= sizeof(*plogi)) { 1504 if (plogi->serv_param.wwpn != port->wwpn) 1505 atomic_clear_mask(ZFCP_STATUS_PORT_DID_DID, 1506 &port->status); 1507 else { 1508 port->wwnn = plogi->serv_param.wwnn; 1509 zfcp_fc_plogi_evaluate(port, plogi); 1510 } 1511 } 1512 break; 1513 case FSF_UNKNOWN_OP_SUBTYPE: 1514 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1515 break; 1516 } 1517 1518 skip_fsfstatus: 1519 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &port->status); 1520 } 1521 1522 /** 1523 * zfcp_fsf_open_port - create and send open port request 1524 * @erp_action: pointer to struct zfcp_erp_action 1525 * Returns: 0 on success, error otherwise 1526 */ 1527 int zfcp_fsf_open_port(struct zfcp_erp_action *erp_action) 1528 { 1529 volatile struct qdio_buffer_element *sbale; 1530 struct zfcp_adapter *adapter = erp_action->adapter; 1531 struct zfcp_fsf_req *req; 1532 int retval = -EIO; 1533 1534 spin_lock(&adapter->req_q.lock); 1535 if (zfcp_fsf_req_sbal_get(adapter)) 1536 goto out; 1537 1538 req = zfcp_fsf_req_create(adapter, 1539 FSF_QTCB_OPEN_PORT_WITH_DID, 1540 ZFCP_REQ_AUTO_CLEANUP, 1541 adapter->pool.fsf_req_erp); 1542 if (unlikely(IS_ERR(req))) { 1543 retval = PTR_ERR(req); 1544 goto out; 1545 } 1546 1547 sbale = zfcp_qdio_sbale_req(req); 1548 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1549 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1550 1551 req->handler = zfcp_fsf_open_port_handler; 1552 req->qtcb->bottom.support.d_id = erp_action->port->d_id; 1553 req->data = erp_action->port; 1554 req->erp_action = erp_action; 1555 erp_action->fsf_req = req; 1556 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->port->status); 1557 1558 zfcp_fsf_start_erp_timer(req); 1559 retval = zfcp_fsf_req_send(req); 1560 if (retval) { 1561 zfcp_fsf_req_free(req); 1562 erp_action->fsf_req = NULL; 1563 } 1564 out: 1565 spin_unlock(&adapter->req_q.lock); 1566 return retval; 1567 } 1568 1569 static void zfcp_fsf_close_port_handler(struct zfcp_fsf_req *req) 1570 { 1571 struct zfcp_port *port = req->data; 1572 1573 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1574 goto skip_fsfstatus; 1575 1576 switch (req->qtcb->header.fsf_status) { 1577 case FSF_PORT_HANDLE_NOT_VALID: 1578 zfcp_erp_adapter_reopen(port->adapter, 0, 107, req); 1579 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1580 break; 1581 case FSF_ADAPTER_STATUS_AVAILABLE: 1582 break; 1583 case FSF_GOOD: 1584 zfcp_erp_modify_port_status(port, 33, req, 1585 ZFCP_STATUS_COMMON_OPEN, 1586 ZFCP_CLEAR); 1587 break; 1588 } 1589 1590 skip_fsfstatus: 1591 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &port->status); 1592 } 1593 1594 /** 1595 * zfcp_fsf_close_port - create and send close port request 1596 * @erp_action: pointer to struct zfcp_erp_action 1597 * Returns: 0 on success, error otherwise 1598 */ 1599 int zfcp_fsf_close_port(struct zfcp_erp_action *erp_action) 1600 { 1601 volatile struct qdio_buffer_element *sbale; 1602 struct zfcp_adapter *adapter = erp_action->adapter; 1603 struct zfcp_fsf_req *req; 1604 int retval = -EIO; 1605 1606 spin_lock(&adapter->req_q.lock); 1607 if (zfcp_fsf_req_sbal_get(adapter)) 1608 goto out; 1609 1610 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PORT, 1611 ZFCP_REQ_AUTO_CLEANUP, 1612 adapter->pool.fsf_req_erp); 1613 if (unlikely(IS_ERR(req))) { 1614 retval = PTR_ERR(req); 1615 goto out; 1616 } 1617 1618 sbale = zfcp_qdio_sbale_req(req); 1619 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1620 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1621 1622 req->handler = zfcp_fsf_close_port_handler; 1623 req->data = erp_action->port; 1624 req->erp_action = erp_action; 1625 req->qtcb->header.port_handle = erp_action->port->handle; 1626 erp_action->fsf_req = req; 1627 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->port->status); 1628 1629 zfcp_fsf_start_erp_timer(req); 1630 retval = zfcp_fsf_req_send(req); 1631 if (retval) { 1632 zfcp_fsf_req_free(req); 1633 erp_action->fsf_req = NULL; 1634 } 1635 out: 1636 spin_unlock(&adapter->req_q.lock); 1637 return retval; 1638 } 1639 1640 static void zfcp_fsf_close_physical_port_handler(struct zfcp_fsf_req *req) 1641 { 1642 struct zfcp_port *port = req->data; 1643 struct fsf_qtcb_header *header = &req->qtcb->header; 1644 struct zfcp_unit *unit; 1645 1646 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1647 goto skip_fsfstatus; 1648 1649 switch (header->fsf_status) { 1650 case FSF_PORT_HANDLE_NOT_VALID: 1651 zfcp_erp_adapter_reopen(port->adapter, 0, 108, req); 1652 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1653 break; 1654 case FSF_ACCESS_DENIED: 1655 zfcp_fsf_access_denied_port(req, port); 1656 break; 1657 case FSF_PORT_BOXED: 1658 zfcp_erp_port_boxed(port, 50, req); 1659 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 1660 ZFCP_STATUS_FSFREQ_RETRY; 1661 /* can't use generic zfcp_erp_modify_port_status because 1662 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port */ 1663 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status); 1664 list_for_each_entry(unit, &port->unit_list_head, list) 1665 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 1666 &unit->status); 1667 break; 1668 case FSF_ADAPTER_STATUS_AVAILABLE: 1669 switch (header->fsf_status_qual.word[0]) { 1670 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1671 /* fall through */ 1672 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1673 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1674 break; 1675 } 1676 break; 1677 case FSF_GOOD: 1678 /* can't use generic zfcp_erp_modify_port_status because 1679 * ZFCP_STATUS_COMMON_OPEN must not be reset for the port 1680 */ 1681 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_OPEN, &port->status); 1682 list_for_each_entry(unit, &port->unit_list_head, list) 1683 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, 1684 &unit->status); 1685 break; 1686 } 1687 skip_fsfstatus: 1688 atomic_clear_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, &port->status); 1689 } 1690 1691 /** 1692 * zfcp_fsf_close_physical_port - close physical port 1693 * @erp_action: pointer to struct zfcp_erp_action 1694 * Returns: 0 on success 1695 */ 1696 int zfcp_fsf_close_physical_port(struct zfcp_erp_action *erp_action) 1697 { 1698 volatile struct qdio_buffer_element *sbale; 1699 struct zfcp_adapter *adapter = erp_action->adapter; 1700 struct zfcp_fsf_req *req; 1701 int retval = -EIO; 1702 1703 spin_lock(&adapter->req_q.lock); 1704 if (zfcp_fsf_req_sbal_get(adapter)) 1705 goto out; 1706 1707 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_PHYSICAL_PORT, 1708 ZFCP_REQ_AUTO_CLEANUP, 1709 adapter->pool.fsf_req_erp); 1710 if (unlikely(IS_ERR(req))) { 1711 retval = PTR_ERR(req); 1712 goto out; 1713 } 1714 1715 sbale = zfcp_qdio_sbale_req(req); 1716 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1717 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1718 1719 req->data = erp_action->port; 1720 req->qtcb->header.port_handle = erp_action->port->handle; 1721 req->erp_action = erp_action; 1722 req->handler = zfcp_fsf_close_physical_port_handler; 1723 erp_action->fsf_req = req; 1724 atomic_set_mask(ZFCP_STATUS_PORT_PHYS_CLOSING, 1725 &erp_action->port->status); 1726 1727 zfcp_fsf_start_erp_timer(req); 1728 retval = zfcp_fsf_req_send(req); 1729 if (retval) { 1730 zfcp_fsf_req_free(req); 1731 erp_action->fsf_req = NULL; 1732 } 1733 out: 1734 spin_unlock(&adapter->req_q.lock); 1735 return retval; 1736 } 1737 1738 static void zfcp_fsf_open_unit_handler(struct zfcp_fsf_req *req) 1739 { 1740 struct zfcp_adapter *adapter = req->adapter; 1741 struct zfcp_unit *unit = req->data; 1742 struct fsf_qtcb_header *header = &req->qtcb->header; 1743 struct fsf_qtcb_bottom_support *bottom = &req->qtcb->bottom.support; 1744 struct fsf_queue_designator *queue_designator = 1745 &header->fsf_status_qual.fsf_queue_designator; 1746 int exclusive, readwrite; 1747 1748 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1749 goto skip_fsfstatus; 1750 1751 atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED | 1752 ZFCP_STATUS_COMMON_ACCESS_BOXED | 1753 ZFCP_STATUS_UNIT_SHARED | 1754 ZFCP_STATUS_UNIT_READONLY, 1755 &unit->status); 1756 1757 switch (header->fsf_status) { 1758 1759 case FSF_PORT_HANDLE_NOT_VALID: 1760 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 109, req); 1761 /* fall through */ 1762 case FSF_LUN_ALREADY_OPEN: 1763 break; 1764 case FSF_ACCESS_DENIED: 1765 zfcp_fsf_access_denied_unit(req, unit); 1766 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status); 1767 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status); 1768 break; 1769 case FSF_PORT_BOXED: 1770 zfcp_erp_port_boxed(unit->port, 51, req); 1771 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 1772 ZFCP_STATUS_FSFREQ_RETRY; 1773 break; 1774 case FSF_LUN_SHARING_VIOLATION: 1775 if (header->fsf_status_qual.word[0]) 1776 dev_warn(&adapter->ccw_device->dev, 1777 "FCP-LUN 0x%Lx at the remote port " 1778 "with WWPN 0x%Lx " 1779 "connected to the adapter " 1780 "is already in use in LPAR%d, CSS%d.\n", 1781 unit->fcp_lun, 1782 unit->port->wwpn, 1783 queue_designator->hla, 1784 queue_designator->cssid); 1785 else 1786 zfcp_act_eval_err(adapter, 1787 header->fsf_status_qual.word[2]); 1788 zfcp_erp_unit_access_denied(unit, 60, req); 1789 atomic_clear_mask(ZFCP_STATUS_UNIT_SHARED, &unit->status); 1790 atomic_clear_mask(ZFCP_STATUS_UNIT_READONLY, &unit->status); 1791 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1792 break; 1793 case FSF_MAXIMUM_NUMBER_OF_LUNS_EXCEEDED: 1794 dev_warn(&adapter->ccw_device->dev, 1795 "The adapter ran out of resources. There is no " 1796 "handle available for unit 0x%016Lx on port 0x%016Lx.", 1797 unit->fcp_lun, unit->port->wwpn); 1798 zfcp_erp_unit_failed(unit, 34, req); 1799 /* fall through */ 1800 case FSF_INVALID_COMMAND_OPTION: 1801 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1802 break; 1803 case FSF_ADAPTER_STATUS_AVAILABLE: 1804 switch (header->fsf_status_qual.word[0]) { 1805 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1806 zfcp_test_link(unit->port); 1807 /* fall through */ 1808 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1809 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1810 break; 1811 } 1812 break; 1813 1814 case FSF_GOOD: 1815 unit->handle = header->lun_handle; 1816 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status); 1817 1818 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE) && 1819 (adapter->adapter_features & FSF_FEATURE_LUN_SHARING) && 1820 (adapter->ccw_device->id.dev_model != ZFCP_DEVICE_MODEL_PRIV)) { 1821 exclusive = (bottom->lun_access_info & 1822 FSF_UNIT_ACCESS_EXCLUSIVE); 1823 readwrite = (bottom->lun_access_info & 1824 FSF_UNIT_ACCESS_OUTBOUND_TRANSFER); 1825 1826 if (!exclusive) 1827 atomic_set_mask(ZFCP_STATUS_UNIT_SHARED, 1828 &unit->status); 1829 1830 if (!readwrite) { 1831 atomic_set_mask(ZFCP_STATUS_UNIT_READONLY, 1832 &unit->status); 1833 dev_info(&adapter->ccw_device->dev, 1834 "Read-only access for unit 0x%016Lx " 1835 "on port 0x%016Lx.\n", 1836 unit->fcp_lun, unit->port->wwpn); 1837 } 1838 1839 if (exclusive && !readwrite) { 1840 dev_err(&adapter->ccw_device->dev, 1841 "Exclusive access of read-only unit " 1842 "0x%016Lx on port 0x%016Lx not " 1843 "supported, disabling unit.\n", 1844 unit->fcp_lun, unit->port->wwpn); 1845 zfcp_erp_unit_failed(unit, 35, req); 1846 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1847 zfcp_erp_unit_shutdown(unit, 0, 80, req); 1848 } else if (!exclusive && readwrite) { 1849 dev_err(&adapter->ccw_device->dev, 1850 "Shared access of read-write unit " 1851 "0x%016Lx on port 0x%016Lx not " 1852 "supported, disabling unit.\n", 1853 unit->fcp_lun, unit->port->wwpn); 1854 zfcp_erp_unit_failed(unit, 36, req); 1855 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1856 zfcp_erp_unit_shutdown(unit, 0, 81, req); 1857 } 1858 } 1859 break; 1860 } 1861 1862 skip_fsfstatus: 1863 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING, &unit->status); 1864 } 1865 1866 /** 1867 * zfcp_fsf_open_unit - open unit 1868 * @erp_action: pointer to struct zfcp_erp_action 1869 * Returns: 0 on success, error otherwise 1870 */ 1871 int zfcp_fsf_open_unit(struct zfcp_erp_action *erp_action) 1872 { 1873 volatile struct qdio_buffer_element *sbale; 1874 struct zfcp_adapter *adapter = erp_action->adapter; 1875 struct zfcp_fsf_req *req; 1876 int retval = -EIO; 1877 1878 spin_lock(&adapter->req_q.lock); 1879 if (zfcp_fsf_req_sbal_get(adapter)) 1880 goto out; 1881 1882 req = zfcp_fsf_req_create(adapter, FSF_QTCB_OPEN_LUN, 1883 ZFCP_REQ_AUTO_CLEANUP, 1884 adapter->pool.fsf_req_erp); 1885 if (unlikely(IS_ERR(req))) { 1886 retval = PTR_ERR(req); 1887 goto out; 1888 } 1889 1890 sbale = zfcp_qdio_sbale_req(req); 1891 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1892 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1893 1894 req->qtcb->header.port_handle = erp_action->port->handle; 1895 req->qtcb->bottom.support.fcp_lun = erp_action->unit->fcp_lun; 1896 req->handler = zfcp_fsf_open_unit_handler; 1897 req->data = erp_action->unit; 1898 req->erp_action = erp_action; 1899 erp_action->fsf_req = req; 1900 1901 if (!(adapter->connection_features & FSF_FEATURE_NPIV_MODE)) 1902 req->qtcb->bottom.support.option = FSF_OPEN_LUN_SUPPRESS_BOXING; 1903 1904 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING, &erp_action->unit->status); 1905 1906 zfcp_fsf_start_erp_timer(req); 1907 retval = zfcp_fsf_req_send(req); 1908 if (retval) { 1909 zfcp_fsf_req_free(req); 1910 erp_action->fsf_req = NULL; 1911 } 1912 out: 1913 spin_unlock(&adapter->req_q.lock); 1914 return retval; 1915 } 1916 1917 static void zfcp_fsf_close_unit_handler(struct zfcp_fsf_req *req) 1918 { 1919 struct zfcp_unit *unit = req->data; 1920 1921 if (req->status & ZFCP_STATUS_FSFREQ_ERROR) 1922 goto skip_fsfstatus; 1923 1924 switch (req->qtcb->header.fsf_status) { 1925 case FSF_PORT_HANDLE_NOT_VALID: 1926 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 110, req); 1927 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1928 break; 1929 case FSF_LUN_HANDLE_NOT_VALID: 1930 zfcp_erp_port_reopen(unit->port, 0, 111, req); 1931 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1932 break; 1933 case FSF_PORT_BOXED: 1934 zfcp_erp_port_boxed(unit->port, 52, req); 1935 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 1936 ZFCP_STATUS_FSFREQ_RETRY; 1937 break; 1938 case FSF_ADAPTER_STATUS_AVAILABLE: 1939 switch (req->qtcb->header.fsf_status_qual.word[0]) { 1940 case FSF_SQ_INVOKE_LINK_TEST_PROCEDURE: 1941 zfcp_test_link(unit->port); 1942 /* fall through */ 1943 case FSF_SQ_ULP_DEPENDENT_ERP_REQUIRED: 1944 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 1945 break; 1946 } 1947 break; 1948 case FSF_GOOD: 1949 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status); 1950 break; 1951 } 1952 skip_fsfstatus: 1953 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING, &unit->status); 1954 } 1955 1956 /** 1957 * zfcp_fsf_close_unit - close zfcp unit 1958 * @erp_action: pointer to struct zfcp_unit 1959 * Returns: 0 on success, error otherwise 1960 */ 1961 int zfcp_fsf_close_unit(struct zfcp_erp_action *erp_action) 1962 { 1963 volatile struct qdio_buffer_element *sbale; 1964 struct zfcp_adapter *adapter = erp_action->adapter; 1965 struct zfcp_fsf_req *req; 1966 int retval = -EIO; 1967 1968 spin_lock(&adapter->req_q.lock); 1969 if (zfcp_fsf_req_sbal_get(adapter)) 1970 goto out; 1971 req = zfcp_fsf_req_create(adapter, FSF_QTCB_CLOSE_LUN, 1972 ZFCP_REQ_AUTO_CLEANUP, 1973 adapter->pool.fsf_req_erp); 1974 if (unlikely(IS_ERR(req))) { 1975 retval = PTR_ERR(req); 1976 goto out; 1977 } 1978 1979 sbale = zfcp_qdio_sbale_req(req); 1980 sbale[0].flags |= SBAL_FLAGS0_TYPE_READ; 1981 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 1982 1983 req->qtcb->header.port_handle = erp_action->port->handle; 1984 req->qtcb->header.lun_handle = erp_action->unit->handle; 1985 req->handler = zfcp_fsf_close_unit_handler; 1986 req->data = erp_action->unit; 1987 req->erp_action = erp_action; 1988 erp_action->fsf_req = req; 1989 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING, &erp_action->unit->status); 1990 1991 zfcp_fsf_start_erp_timer(req); 1992 retval = zfcp_fsf_req_send(req); 1993 if (retval) { 1994 zfcp_fsf_req_free(req); 1995 erp_action->fsf_req = NULL; 1996 } 1997 out: 1998 spin_unlock(&adapter->req_q.lock); 1999 return retval; 2000 } 2001 2002 static void zfcp_fsf_update_lat(struct fsf_latency_record *lat_rec, u32 lat) 2003 { 2004 lat_rec->sum += lat; 2005 lat_rec->min = min(lat_rec->min, lat); 2006 lat_rec->max = max(lat_rec->max, lat); 2007 } 2008 2009 static void zfcp_fsf_req_latency(struct zfcp_fsf_req *req) 2010 { 2011 struct fsf_qual_latency_info *lat_inf; 2012 struct latency_cont *lat; 2013 struct zfcp_unit *unit = req->unit; 2014 unsigned long flags; 2015 2016 lat_inf = &req->qtcb->prefix.prot_status_qual.latency_info; 2017 2018 switch (req->qtcb->bottom.io.data_direction) { 2019 case FSF_DATADIR_READ: 2020 lat = &unit->latencies.read; 2021 break; 2022 case FSF_DATADIR_WRITE: 2023 lat = &unit->latencies.write; 2024 break; 2025 case FSF_DATADIR_CMND: 2026 lat = &unit->latencies.cmd; 2027 break; 2028 default: 2029 return; 2030 } 2031 2032 spin_lock_irqsave(&unit->latencies.lock, flags); 2033 zfcp_fsf_update_lat(&lat->channel, lat_inf->channel_lat); 2034 zfcp_fsf_update_lat(&lat->fabric, lat_inf->fabric_lat); 2035 lat->counter++; 2036 spin_unlock_irqrestore(&unit->latencies.lock, flags); 2037 } 2038 2039 static void zfcp_fsf_send_fcp_command_task_handler(struct zfcp_fsf_req *req) 2040 { 2041 struct scsi_cmnd *scpnt = req->data; 2042 struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *) 2043 &(req->qtcb->bottom.io.fcp_rsp); 2044 u32 sns_len; 2045 char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1]; 2046 unsigned long flags; 2047 2048 if (unlikely(!scpnt)) 2049 return; 2050 2051 read_lock_irqsave(&req->adapter->abort_lock, flags); 2052 2053 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ABORTED)) { 2054 set_host_byte(scpnt, DID_SOFT_ERROR); 2055 set_driver_byte(scpnt, SUGGEST_RETRY); 2056 goto skip_fsfstatus; 2057 } 2058 2059 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) { 2060 set_host_byte(scpnt, DID_ERROR); 2061 goto skip_fsfstatus; 2062 } 2063 2064 set_msg_byte(scpnt, COMMAND_COMPLETE); 2065 2066 scpnt->result |= fcp_rsp_iu->scsi_status; 2067 2068 if (req->adapter->adapter_features & FSF_FEATURE_MEASUREMENT_DATA) 2069 zfcp_fsf_req_latency(req); 2070 2071 if (unlikely(fcp_rsp_iu->validity.bits.fcp_rsp_len_valid)) { 2072 if (fcp_rsp_info[3] == RSP_CODE_GOOD) 2073 set_host_byte(scpnt, DID_OK); 2074 else { 2075 set_host_byte(scpnt, DID_ERROR); 2076 goto skip_fsfstatus; 2077 } 2078 } 2079 2080 if (unlikely(fcp_rsp_iu->validity.bits.fcp_sns_len_valid)) { 2081 sns_len = FSF_FCP_RSP_SIZE - sizeof(struct fcp_rsp_iu) + 2082 fcp_rsp_iu->fcp_rsp_len; 2083 sns_len = min(sns_len, (u32) SCSI_SENSE_BUFFERSIZE); 2084 sns_len = min(sns_len, fcp_rsp_iu->fcp_sns_len); 2085 2086 memcpy(scpnt->sense_buffer, 2087 zfcp_get_fcp_sns_info_ptr(fcp_rsp_iu), sns_len); 2088 } 2089 2090 if (unlikely(fcp_rsp_iu->validity.bits.fcp_resid_under)) { 2091 scsi_set_resid(scpnt, fcp_rsp_iu->fcp_resid); 2092 if (scsi_bufflen(scpnt) - scsi_get_resid(scpnt) < 2093 scpnt->underflow) 2094 set_host_byte(scpnt, DID_ERROR); 2095 } 2096 skip_fsfstatus: 2097 if (scpnt->result != 0) 2098 zfcp_scsi_dbf_event_result("erro", 3, req->adapter, scpnt, req); 2099 else if (scpnt->retries > 0) 2100 zfcp_scsi_dbf_event_result("retr", 4, req->adapter, scpnt, req); 2101 else 2102 zfcp_scsi_dbf_event_result("norm", 6, req->adapter, scpnt, req); 2103 2104 scpnt->host_scribble = NULL; 2105 (scpnt->scsi_done) (scpnt); 2106 /* 2107 * We must hold this lock until scsi_done has been called. 2108 * Otherwise we may call scsi_done after abort regarding this 2109 * command has completed. 2110 * Note: scsi_done must not block! 2111 */ 2112 read_unlock_irqrestore(&req->adapter->abort_lock, flags); 2113 } 2114 2115 static void zfcp_fsf_send_fcp_ctm_handler(struct zfcp_fsf_req *req) 2116 { 2117 struct fcp_rsp_iu *fcp_rsp_iu = (struct fcp_rsp_iu *) 2118 &(req->qtcb->bottom.io.fcp_rsp); 2119 char *fcp_rsp_info = (unsigned char *) &fcp_rsp_iu[1]; 2120 2121 if ((fcp_rsp_info[3] != RSP_CODE_GOOD) || 2122 (req->status & ZFCP_STATUS_FSFREQ_ERROR)) 2123 req->status |= ZFCP_STATUS_FSFREQ_TMFUNCFAILED; 2124 } 2125 2126 2127 static void zfcp_fsf_send_fcp_command_handler(struct zfcp_fsf_req *req) 2128 { 2129 struct zfcp_unit *unit; 2130 struct fsf_qtcb_header *header = &req->qtcb->header; 2131 2132 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT)) 2133 unit = req->data; 2134 else 2135 unit = req->unit; 2136 2137 if (unlikely(req->status & ZFCP_STATUS_FSFREQ_ERROR)) 2138 goto skip_fsfstatus; 2139 2140 switch (header->fsf_status) { 2141 case FSF_HANDLE_MISMATCH: 2142 case FSF_PORT_HANDLE_NOT_VALID: 2143 zfcp_erp_adapter_reopen(unit->port->adapter, 0, 112, req); 2144 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2145 break; 2146 case FSF_FCPLUN_NOT_VALID: 2147 case FSF_LUN_HANDLE_NOT_VALID: 2148 zfcp_erp_port_reopen(unit->port, 0, 113, req); 2149 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2150 break; 2151 case FSF_SERVICE_CLASS_NOT_SUPPORTED: 2152 zfcp_fsf_class_not_supp(req); 2153 break; 2154 case FSF_ACCESS_DENIED: 2155 zfcp_fsf_access_denied_unit(req, unit); 2156 break; 2157 case FSF_DIRECTION_INDICATOR_NOT_VALID: 2158 dev_err(&req->adapter->ccw_device->dev, 2159 "Invalid data direction (%d) given for unit " 2160 "0x%016Lx on port 0x%016Lx, shutting down " 2161 "adapter.\n", 2162 req->qtcb->bottom.io.data_direction, 2163 unit->fcp_lun, unit->port->wwpn); 2164 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 133, req); 2165 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2166 break; 2167 case FSF_CMND_LENGTH_NOT_VALID: 2168 dev_err(&req->adapter->ccw_device->dev, 2169 "An invalid control-data-block length field (%d) " 2170 "was found in a command for unit 0x%016Lx on port " 2171 "0x%016Lx. Shutting down adapter.\n", 2172 req->qtcb->bottom.io.fcp_cmnd_length, 2173 unit->fcp_lun, unit->port->wwpn); 2174 zfcp_erp_adapter_shutdown(unit->port->adapter, 0, 134, req); 2175 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2176 break; 2177 case FSF_PORT_BOXED: 2178 zfcp_erp_port_boxed(unit->port, 53, req); 2179 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 2180 ZFCP_STATUS_FSFREQ_RETRY; 2181 break; 2182 case FSF_LUN_BOXED: 2183 zfcp_erp_unit_boxed(unit, 54, req); 2184 req->status |= ZFCP_STATUS_FSFREQ_ERROR | 2185 ZFCP_STATUS_FSFREQ_RETRY; 2186 break; 2187 case FSF_ADAPTER_STATUS_AVAILABLE: 2188 if (header->fsf_status_qual.word[0] == 2189 FSF_SQ_INVOKE_LINK_TEST_PROCEDURE) 2190 zfcp_test_link(unit->port); 2191 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2192 break; 2193 } 2194 skip_fsfstatus: 2195 if (req->status & ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT) 2196 zfcp_fsf_send_fcp_ctm_handler(req); 2197 else { 2198 zfcp_fsf_send_fcp_command_task_handler(req); 2199 req->unit = NULL; 2200 zfcp_unit_put(unit); 2201 } 2202 } 2203 2204 /** 2205 * zfcp_fsf_send_fcp_command_task - initiate an FCP command (for a SCSI command) 2206 * @adapter: adapter where scsi command is issued 2207 * @unit: unit where command is sent to 2208 * @scsi_cmnd: scsi command to be sent 2209 * @timer: timer to be started when request is initiated 2210 * @req_flags: flags for fsf_request 2211 */ 2212 int zfcp_fsf_send_fcp_command_task(struct zfcp_adapter *adapter, 2213 struct zfcp_unit *unit, 2214 struct scsi_cmnd *scsi_cmnd, 2215 int use_timer, int req_flags) 2216 { 2217 struct zfcp_fsf_req *req; 2218 struct fcp_cmnd_iu *fcp_cmnd_iu; 2219 unsigned int sbtype; 2220 int real_bytes, retval = -EIO; 2221 2222 if (unlikely(!(atomic_read(&unit->status) & 2223 ZFCP_STATUS_COMMON_UNBLOCKED))) 2224 return -EBUSY; 2225 2226 spin_lock(&adapter->req_q.lock); 2227 if (!atomic_read(&adapter->req_q.count)) 2228 goto out; 2229 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags, 2230 adapter->pool.fsf_req_scsi); 2231 if (unlikely(IS_ERR(req))) { 2232 retval = PTR_ERR(req); 2233 goto out; 2234 } 2235 2236 zfcp_unit_get(unit); 2237 req->unit = unit; 2238 req->data = scsi_cmnd; 2239 req->handler = zfcp_fsf_send_fcp_command_handler; 2240 req->qtcb->header.lun_handle = unit->handle; 2241 req->qtcb->header.port_handle = unit->port->handle; 2242 req->qtcb->bottom.io.service_class = FSF_CLASS_3; 2243 2244 scsi_cmnd->host_scribble = (unsigned char *) req->req_id; 2245 2246 fcp_cmnd_iu = (struct fcp_cmnd_iu *) &(req->qtcb->bottom.io.fcp_cmnd); 2247 fcp_cmnd_iu->fcp_lun = unit->fcp_lun; 2248 /* 2249 * set depending on data direction: 2250 * data direction bits in SBALE (SB Type) 2251 * data direction bits in QTCB 2252 * data direction bits in FCP_CMND IU 2253 */ 2254 switch (scsi_cmnd->sc_data_direction) { 2255 case DMA_NONE: 2256 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND; 2257 sbtype = SBAL_FLAGS0_TYPE_READ; 2258 break; 2259 case DMA_FROM_DEVICE: 2260 req->qtcb->bottom.io.data_direction = FSF_DATADIR_READ; 2261 sbtype = SBAL_FLAGS0_TYPE_READ; 2262 fcp_cmnd_iu->rddata = 1; 2263 break; 2264 case DMA_TO_DEVICE: 2265 req->qtcb->bottom.io.data_direction = FSF_DATADIR_WRITE; 2266 sbtype = SBAL_FLAGS0_TYPE_WRITE; 2267 fcp_cmnd_iu->wddata = 1; 2268 break; 2269 case DMA_BIDIRECTIONAL: 2270 default: 2271 retval = -EIO; 2272 goto failed_scsi_cmnd; 2273 } 2274 2275 if (likely((scsi_cmnd->device->simple_tags) || 2276 ((atomic_read(&unit->status) & ZFCP_STATUS_UNIT_READONLY) && 2277 (atomic_read(&unit->status) & ZFCP_STATUS_UNIT_SHARED)))) 2278 fcp_cmnd_iu->task_attribute = SIMPLE_Q; 2279 else 2280 fcp_cmnd_iu->task_attribute = UNTAGGED; 2281 2282 if (unlikely(scsi_cmnd->cmd_len > FCP_CDB_LENGTH)) 2283 fcp_cmnd_iu->add_fcp_cdb_length = 2284 (scsi_cmnd->cmd_len - FCP_CDB_LENGTH) >> 2; 2285 2286 memcpy(fcp_cmnd_iu->fcp_cdb, scsi_cmnd->cmnd, scsi_cmnd->cmd_len); 2287 2288 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) + 2289 fcp_cmnd_iu->add_fcp_cdb_length + sizeof(fcp_dl_t); 2290 2291 real_bytes = zfcp_qdio_sbals_from_sg(req, sbtype, 2292 scsi_sglist(scsi_cmnd), 2293 FSF_MAX_SBALS_PER_REQ); 2294 if (unlikely(real_bytes < 0)) { 2295 if (req->sbal_number < FSF_MAX_SBALS_PER_REQ) 2296 retval = -EIO; 2297 else { 2298 dev_err(&adapter->ccw_device->dev, 2299 "SCSI request too large. " 2300 "Shutting down unit 0x%016Lx on port " 2301 "0x%016Lx.\n", unit->fcp_lun, 2302 unit->port->wwpn); 2303 zfcp_erp_unit_shutdown(unit, 0, 131, req); 2304 retval = -EINVAL; 2305 } 2306 goto failed_scsi_cmnd; 2307 } 2308 2309 zfcp_set_fcp_dl(fcp_cmnd_iu, real_bytes); 2310 2311 if (use_timer) 2312 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 2313 2314 retval = zfcp_fsf_req_send(req); 2315 if (unlikely(retval)) 2316 goto failed_scsi_cmnd; 2317 2318 goto out; 2319 2320 failed_scsi_cmnd: 2321 zfcp_unit_put(unit); 2322 zfcp_fsf_req_free(req); 2323 scsi_cmnd->host_scribble = NULL; 2324 out: 2325 spin_unlock(&adapter->req_q.lock); 2326 return retval; 2327 } 2328 2329 /** 2330 * zfcp_fsf_send_fcp_ctm - send SCSI task management command 2331 * @adapter: pointer to struct zfcp-adapter 2332 * @unit: pointer to struct zfcp_unit 2333 * @tm_flags: unsigned byte for task management flags 2334 * @req_flags: int request flags 2335 * Returns: on success pointer to struct fsf_req, NULL otherwise 2336 */ 2337 struct zfcp_fsf_req *zfcp_fsf_send_fcp_ctm(struct zfcp_adapter *adapter, 2338 struct zfcp_unit *unit, 2339 u8 tm_flags, int req_flags) 2340 { 2341 volatile struct qdio_buffer_element *sbale; 2342 struct zfcp_fsf_req *req = NULL; 2343 struct fcp_cmnd_iu *fcp_cmnd_iu; 2344 2345 if (unlikely(!(atomic_read(&unit->status) & 2346 ZFCP_STATUS_COMMON_UNBLOCKED))) 2347 return NULL; 2348 2349 spin_lock(&adapter->req_q.lock); 2350 if (!atomic_read(&adapter->req_q.count)) 2351 goto out; 2352 req = zfcp_fsf_req_create(adapter, FSF_QTCB_FCP_CMND, req_flags, 2353 adapter->pool.fsf_req_scsi); 2354 if (unlikely(IS_ERR(req))) 2355 goto out; 2356 2357 req->status |= ZFCP_STATUS_FSFREQ_TASK_MANAGEMENT; 2358 req->data = unit; 2359 req->handler = zfcp_fsf_send_fcp_command_handler; 2360 req->qtcb->header.lun_handle = unit->handle; 2361 req->qtcb->header.port_handle = unit->port->handle; 2362 req->qtcb->bottom.io.data_direction = FSF_DATADIR_CMND; 2363 req->qtcb->bottom.io.service_class = FSF_CLASS_3; 2364 req->qtcb->bottom.io.fcp_cmnd_length = sizeof(struct fcp_cmnd_iu) + 2365 sizeof(fcp_dl_t); 2366 2367 sbale = zfcp_qdio_sbale_req(req); 2368 sbale[0].flags |= SBAL_FLAGS0_TYPE_WRITE; 2369 sbale[1].flags |= SBAL_FLAGS_LAST_ENTRY; 2370 2371 fcp_cmnd_iu = (struct fcp_cmnd_iu *) &req->qtcb->bottom.io.fcp_cmnd; 2372 fcp_cmnd_iu->fcp_lun = unit->fcp_lun; 2373 fcp_cmnd_iu->task_management_flags = tm_flags; 2374 2375 zfcp_fsf_start_timer(req, ZFCP_SCSI_ER_TIMEOUT); 2376 if (!zfcp_fsf_req_send(req)) 2377 goto out; 2378 2379 zfcp_fsf_req_free(req); 2380 req = NULL; 2381 out: 2382 spin_unlock(&adapter->req_q.lock); 2383 return req; 2384 } 2385 2386 static void zfcp_fsf_control_file_handler(struct zfcp_fsf_req *req) 2387 { 2388 if (req->qtcb->header.fsf_status != FSF_GOOD) 2389 req->status |= ZFCP_STATUS_FSFREQ_ERROR; 2390 } 2391 2392 /** 2393 * zfcp_fsf_control_file - control file upload/download 2394 * @adapter: pointer to struct zfcp_adapter 2395 * @fsf_cfdc: pointer to struct zfcp_fsf_cfdc 2396 * Returns: on success pointer to struct zfcp_fsf_req, NULL otherwise 2397 */ 2398 struct zfcp_fsf_req *zfcp_fsf_control_file(struct zfcp_adapter *adapter, 2399 struct zfcp_fsf_cfdc *fsf_cfdc) 2400 { 2401 volatile struct qdio_buffer_element *sbale; 2402 struct zfcp_fsf_req *req = NULL; 2403 struct fsf_qtcb_bottom_support *bottom; 2404 int direction, retval = -EIO, bytes; 2405 2406 if (!(adapter->adapter_features & FSF_FEATURE_CFDC)) 2407 return ERR_PTR(-EOPNOTSUPP); 2408 2409 switch (fsf_cfdc->command) { 2410 case FSF_QTCB_DOWNLOAD_CONTROL_FILE: 2411 direction = SBAL_FLAGS0_TYPE_WRITE; 2412 break; 2413 case FSF_QTCB_UPLOAD_CONTROL_FILE: 2414 direction = SBAL_FLAGS0_TYPE_READ; 2415 break; 2416 default: 2417 return ERR_PTR(-EINVAL); 2418 } 2419 2420 spin_lock(&adapter->req_q.lock); 2421 if (zfcp_fsf_req_sbal_get(adapter)) 2422 goto out; 2423 2424 req = zfcp_fsf_req_create(adapter, fsf_cfdc->command, 0, NULL); 2425 if (unlikely(IS_ERR(req))) { 2426 retval = -EPERM; 2427 goto out; 2428 } 2429 2430 req->handler = zfcp_fsf_control_file_handler; 2431 2432 sbale = zfcp_qdio_sbale_req(req); 2433 sbale[0].flags |= direction; 2434 2435 bottom = &req->qtcb->bottom.support; 2436 bottom->operation_subtype = FSF_CFDC_OPERATION_SUBTYPE; 2437 bottom->option = fsf_cfdc->option; 2438 2439 bytes = zfcp_qdio_sbals_from_sg(req, direction, fsf_cfdc->sg, 2440 FSF_MAX_SBALS_PER_REQ); 2441 if (bytes != ZFCP_CFDC_MAX_SIZE) { 2442 retval = -ENOMEM; 2443 zfcp_fsf_req_free(req); 2444 goto out; 2445 } 2446 2447 zfcp_fsf_start_timer(req, ZFCP_FSF_REQUEST_TIMEOUT); 2448 retval = zfcp_fsf_req_send(req); 2449 out: 2450 spin_unlock(&adapter->req_q.lock); 2451 2452 if (!retval) { 2453 wait_event(req->completion_wq, 2454 req->status & ZFCP_STATUS_FSFREQ_COMPLETED); 2455 return req; 2456 } 2457 return ERR_PTR(retval); 2458 } 2459