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