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