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