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