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