?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SCSI] zfcp: minor erp bug fixes
[linux-2.6/mini2440.git] / drivers / s390 / scsi / zfcp_erp.c
blob7f60b6fdf7248676990d07ea3cc6df3f8a095e35
1 /*
2 * This file is part of the zfcp device driver for
3 * FCP adapters for IBM System z9 and zSeries.
4 *
5 * (C) Copyright IBM Corp. 2002, 2006
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2, or (at your option)
10 * any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #define ZFCP_LOG_AREA ZFCP_LOG_AREA_ERP
23
24 #include "zfcp_ext.h"
25
26 static int zfcp_erp_adisc(struct zfcp_port *);
27 static void zfcp_erp_adisc_handler(unsigned long);
28
29 static int zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *, int);
30 static int zfcp_erp_port_forced_reopen_internal(struct zfcp_port *, int);
31 static int zfcp_erp_port_reopen_internal(struct zfcp_port *, int);
32 static int zfcp_erp_unit_reopen_internal(struct zfcp_unit *, int);
33
34 static int zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *, int);
35 static int zfcp_erp_unit_reopen_all_internal(struct zfcp_port *, int);
36
37 static void zfcp_erp_adapter_block(struct zfcp_adapter *, int);
38 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *);
39 static void zfcp_erp_port_block(struct zfcp_port *, int);
40 static void zfcp_erp_port_unblock(struct zfcp_port *);
41 static void zfcp_erp_unit_block(struct zfcp_unit *, int);
42 static void zfcp_erp_unit_unblock(struct zfcp_unit *);
43
44 static int zfcp_erp_thread(void *);
45
46 static int zfcp_erp_strategy(struct zfcp_erp_action *);
47
48 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *);
49 static int zfcp_erp_strategy_memwait(struct zfcp_erp_action *);
50 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *, int);
51 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *, int);
52 static int zfcp_erp_strategy_check_port(struct zfcp_port *, int);
53 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *, int);
54 static int zfcp_erp_strategy_statechange(int, u32, struct zfcp_adapter *,
55 struct zfcp_port *,
56 struct zfcp_unit *, int);
57 static inline int zfcp_erp_strategy_statechange_detected(atomic_t *, u32);
58 static int zfcp_erp_strategy_followup_actions(int, struct zfcp_adapter *,
59 struct zfcp_port *,
60 struct zfcp_unit *, int);
61 static int zfcp_erp_strategy_check_queues(struct zfcp_adapter *);
62 static int zfcp_erp_strategy_check_action(struct zfcp_erp_action *, int);
63
64 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *);
65 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *, int);
66 static int zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *);
67 static void zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *);
68 static void zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *);
69 static int zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *);
70 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *);
71 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *);
72 static int zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *);
73 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *);
74 static int zfcp_erp_adapter_strategy_open_fsf_statusread(
75 struct zfcp_erp_action *);
76
77 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *);
78 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *);
79
80 static int zfcp_erp_port_strategy(struct zfcp_erp_action *);
81 static int zfcp_erp_port_strategy_clearstati(struct zfcp_port *);
82 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *);
83 static int zfcp_erp_port_strategy_open(struct zfcp_erp_action *);
84 static int zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *);
85 static int zfcp_erp_port_strategy_open_nameserver_wakeup(
86 struct zfcp_erp_action *);
87 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *);
88 static int zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *);
89 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *);
90
91 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *);
92 static int zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *);
93 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *);
94 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *);
95
96 static void zfcp_erp_action_dismiss_port(struct zfcp_port *);
97 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *);
98 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *);
99
100 static int zfcp_erp_action_enqueue(int, struct zfcp_adapter *,
101 struct zfcp_port *, struct zfcp_unit *);
102 static int zfcp_erp_action_dequeue(struct zfcp_erp_action *);
103 static void zfcp_erp_action_cleanup(int, struct zfcp_adapter *,
104 struct zfcp_port *, struct zfcp_unit *,
105 int);
106
107 static void zfcp_erp_action_ready(struct zfcp_erp_action *);
108 static int zfcp_erp_action_exists(struct zfcp_erp_action *);
109
110 static inline void zfcp_erp_action_to_ready(struct zfcp_erp_action *);
111 static inline void zfcp_erp_action_to_running(struct zfcp_erp_action *);
112
113 static void zfcp_erp_memwait_handler(unsigned long);
114 static void zfcp_erp_timeout_handler(unsigned long);
115 static inline void zfcp_erp_timeout_init(struct zfcp_erp_action *);
116
117 /**
118 * zfcp_fsf_request_timeout_handler - called if a request timed out
119 * @data: pointer to adapter for handler function
120 *
121 * This function needs to be called if requests (ELS, Generic Service,
122 * or SCSI commands) exceed a certain time limit. The assumption is
123 * that after the time limit the adapter get stuck. So we trigger a reopen of
124 * the adapter. This should not be used for error recovery, SCSI abort
125 * commands and SCSI requests from SCSI mid-layer.
126 */
127 void
128 zfcp_fsf_request_timeout_handler(unsigned long data)
129 {
130 struct zfcp_adapter *adapter;
131
132 adapter = (struct zfcp_adapter *) data;
133
134 zfcp_erp_adapter_reopen(adapter, 0);
135 }
136
137 /**
138 * zfcp_fsf_scsi_er_timeout_handler - timeout handler for scsi eh tasks
139 *
140 * This function needs to be called whenever a SCSI error recovery
141 * action (abort/reset) does not return. Re-opening the adapter means
142 * that the abort/reset command can be returned by zfcp. It won't complete
143 * via the adapter anymore (because qdio queues are closed). If ERP is
144 * already running on this adapter it will be stopped.
145 */
146 void zfcp_fsf_scsi_er_timeout_handler(unsigned long data)
147 {
148 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
149 unsigned long flags;
150
151 ZFCP_LOG_NORMAL("warning: SCSI error recovery timed out. "
152 "Restarting all operations on the adapter %s\n",
153 zfcp_get_busid_by_adapter(adapter));
154 debug_text_event(adapter->erp_dbf, 1, "eh_lmem_tout");
155
156 write_lock_irqsave(&adapter->erp_lock, flags);
157 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
158 &adapter->status)) {
159 zfcp_erp_modify_adapter_status(adapter,
160 ZFCP_STATUS_COMMON_UNBLOCKED|ZFCP_STATUS_COMMON_OPEN,
161 ZFCP_CLEAR);
162 zfcp_erp_action_dismiss_adapter(adapter);
163 write_unlock_irqrestore(&adapter->erp_lock, flags);
164 /* dismiss all pending requests including requests for ERP */
165 zfcp_fsf_req_dismiss_all(adapter);
166 adapter->fsf_req_seq_no = 0;
167 } else
168 write_unlock_irqrestore(&adapter->erp_lock, flags);
169 zfcp_erp_adapter_reopen(adapter, 0);
170 }
171
172 /*
173 * function:
174 *
175 * purpose: called if an adapter failed,
176 * initiates adapter recovery which is done
177 * asynchronously
178 *
179 * returns: 0 - initiated action successfully
180 * <0 - failed to initiate action
181 */
182 int
183 zfcp_erp_adapter_reopen_internal(struct zfcp_adapter *adapter, int clear_mask)
184 {
185 int retval;
186
187 debug_text_event(adapter->erp_dbf, 5, "a_ro");
188 ZFCP_LOG_DEBUG("reopen adapter %s\n",
189 zfcp_get_busid_by_adapter(adapter));
190
191 zfcp_erp_adapter_block(adapter, clear_mask);
192
193 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
194 ZFCP_LOG_DEBUG("skipped reopen of failed adapter %s\n",
195 zfcp_get_busid_by_adapter(adapter));
196 debug_text_event(adapter->erp_dbf, 5, "a_ro_f");
197 /* ensure propagation of failed status to new devices */
198 zfcp_erp_adapter_failed(adapter);
199 retval = -EIO;
200 goto out;
201 }
202 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
203 adapter, NULL, NULL);
204
205 out:
206 return retval;
207 }
208
209 /*
210 * function:
211 *
212 * purpose: Wrappper for zfcp_erp_adapter_reopen_internal
213 * used to ensure the correct locking
214 *
215 * returns: 0 - initiated action successfully
216 * <0 - failed to initiate action
217 */
218 int
219 zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear_mask)
220 {
221 int retval;
222 unsigned long flags;
223
224 read_lock_irqsave(&zfcp_data.config_lock, flags);
225 write_lock(&adapter->erp_lock);
226 retval = zfcp_erp_adapter_reopen_internal(adapter, clear_mask);
227 write_unlock(&adapter->erp_lock);
228 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
229
230 return retval;
231 }
232
233 int
234 zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear_mask)
235 {
236 int retval;
237
238 retval = zfcp_erp_adapter_reopen(adapter,
239 ZFCP_STATUS_COMMON_RUNNING |
240 ZFCP_STATUS_COMMON_ERP_FAILED |
241 clear_mask);
242
243 return retval;
244 }
245
246 int
247 zfcp_erp_port_shutdown(struct zfcp_port *port, int clear_mask)
248 {
249 int retval;
250
251 retval = zfcp_erp_port_reopen(port,
252 ZFCP_STATUS_COMMON_RUNNING |
253 ZFCP_STATUS_COMMON_ERP_FAILED |
254 clear_mask);
255
256 return retval;
257 }
258
259 int
260 zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear_mask)
261 {
262 int retval;
263
264 retval = zfcp_erp_unit_reopen(unit,
265 ZFCP_STATUS_COMMON_RUNNING |
266 ZFCP_STATUS_COMMON_ERP_FAILED |
267 clear_mask);
268
269 return retval;
270 }
271
272
273 /**
274 * zfcp_erp_adisc - send ADISC ELS command
275 * @port: port structure
276 */
277 int
278 zfcp_erp_adisc(struct zfcp_port *port)
279 {
280 struct zfcp_adapter *adapter = port->adapter;
281 struct zfcp_send_els *send_els;
282 struct zfcp_ls_adisc *adisc;
283 void *address = NULL;
284 int retval = 0;
285 struct timer_list *timer;
286
287 send_els = kzalloc(sizeof(struct zfcp_send_els), GFP_ATOMIC);
288 if (send_els == NULL)
289 goto nomem;
290
291 send_els->req = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC);
292 if (send_els->req == NULL)
293 goto nomem;
294
295 send_els->resp = kzalloc(sizeof(struct scatterlist), GFP_ATOMIC);
296 if (send_els->resp == NULL)
297 goto nomem;
298
299 address = (void *) get_zeroed_page(GFP_ATOMIC);
300 if (address == NULL)
301 goto nomem;
302
303 zfcp_address_to_sg(address, send_els->req);
304 address += PAGE_SIZE >> 1;
305 zfcp_address_to_sg(address, send_els->resp);
306 send_els->req_count = send_els->resp_count = 1;
307
308 send_els->adapter = adapter;
309 send_els->port = port;
310 send_els->d_id = port->d_id;
311 send_els->handler = zfcp_erp_adisc_handler;
312 send_els->handler_data = (unsigned long) send_els;
313
314 adisc = zfcp_sg_to_address(send_els->req);
315 send_els->ls_code = adisc->code = ZFCP_LS_ADISC;
316
317 send_els->req->length = sizeof(struct zfcp_ls_adisc);
318 send_els->resp->length = sizeof(struct zfcp_ls_adisc_acc);
319
320 /* acc. to FC-FS, hard_nport_id in ADISC should not be set for ports
321 without FC-AL-2 capability, so we don't set it */
322 adisc->wwpn = fc_host_port_name(adapter->scsi_host);
323 adisc->wwnn = fc_host_node_name(adapter->scsi_host);
324 adisc->nport_id = fc_host_port_id(adapter->scsi_host);
325 ZFCP_LOG_INFO("ADISC request from s_id 0x%08x to d_id 0x%08x "
326 "(wwpn=0x%016Lx, wwnn=0x%016Lx, "
327 "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
328 adisc->nport_id, send_els->d_id, (wwn_t) adisc->wwpn,
329 (wwn_t) adisc->wwnn, adisc->hard_nport_id,
330 adisc->nport_id);
331
332 timer = kmalloc(sizeof(struct timer_list), GFP_ATOMIC);
333 if (!timer)
334 goto nomem;
335
336 init_timer(timer);
337 timer->function = zfcp_fsf_request_timeout_handler;
338 timer->data = (unsigned long) adapter;
339 timer->expires = ZFCP_FSF_REQUEST_TIMEOUT;
340 send_els->timer = timer;
341
342 retval = zfcp_fsf_send_els(send_els);
343 if (retval != 0) {
344 ZFCP_LOG_NORMAL("error: initiation of Send ELS failed for port "
345 "0x%08x on adapter %s\n", send_els->d_id,
346 zfcp_get_busid_by_adapter(adapter));
347 del_timer(send_els->timer);
348 goto freemem;
349 }
350
351 goto out;
352
353 nomem:
354 retval = -ENOMEM;
355 freemem:
356 if (address != NULL)
357 __free_pages(send_els->req->page, 0);
358 if (send_els != NULL) {
359 kfree(send_els->timer);
360 kfree(send_els->req);
361 kfree(send_els->resp);
362 kfree(send_els);
363 }
364 out:
365 return retval;
366 }
367
368
369 /**
370 * zfcp_erp_adisc_handler - handler for ADISC ELS command
371 * @data: pointer to struct zfcp_send_els
372 *
373 * If ADISC failed (LS_RJT or timed out) forced reopen of the port is triggered.
374 */
375 void
376 zfcp_erp_adisc_handler(unsigned long data)
377 {
378 struct zfcp_send_els *send_els;
379 struct zfcp_port *port;
380 struct zfcp_adapter *adapter;
381 u32 d_id;
382 struct zfcp_ls_adisc_acc *adisc;
383
384 send_els = (struct zfcp_send_els *) data;
385
386 del_timer(send_els->timer);
387
388 adapter = send_els->adapter;
389 port = send_els->port;
390 d_id = send_els->d_id;
391
392 /* request rejected or timed out */
393 if (send_els->status != 0) {
394 ZFCP_LOG_NORMAL("ELS request rejected/timed out, "
395 "force physical port reopen "
396 "(adapter %s, port d_id=0x%08x)\n",
397 zfcp_get_busid_by_adapter(adapter), d_id);
398 debug_text_event(adapter->erp_dbf, 3, "forcreop");
399 if (zfcp_erp_port_forced_reopen(port, 0))
400 ZFCP_LOG_NORMAL("failed reopen of port "
401 "(adapter %s, wwpn=0x%016Lx)\n",
402 zfcp_get_busid_by_port(port),
403 port->wwpn);
404 goto out;
405 }
406
407 adisc = zfcp_sg_to_address(send_els->resp);
408
409 ZFCP_LOG_INFO("ADISC response from d_id 0x%08x to s_id "
410 "0x%08x (wwpn=0x%016Lx, wwnn=0x%016Lx, "
411 "hard_nport_id=0x%08x, nport_id=0x%08x)\n",
412 d_id, fc_host_port_id(adapter->scsi_host),
413 (wwn_t) adisc->wwpn, (wwn_t) adisc->wwnn,
414 adisc->hard_nport_id, adisc->nport_id);
415
416 /* set wwnn for port */
417 if (port->wwnn == 0)
418 port->wwnn = adisc->wwnn;
419
420 if (port->wwpn != adisc->wwpn) {
421 ZFCP_LOG_NORMAL("d_id assignment changed, reopening "
422 "port (adapter %s, wwpn=0x%016Lx, "
423 "adisc_resp_wwpn=0x%016Lx)\n",
424 zfcp_get_busid_by_port(port),
425 port->wwpn, (wwn_t) adisc->wwpn);
426 if (zfcp_erp_port_reopen(port, 0))
427 ZFCP_LOG_NORMAL("failed reopen of port "
428 "(adapter %s, wwpn=0x%016Lx)\n",
429 zfcp_get_busid_by_port(port),
430 port->wwpn);
431 }
432
433 out:
434 zfcp_port_put(port);
435 __free_pages(send_els->req->page, 0);
436 kfree(send_els->timer);
437 kfree(send_els->req);
438 kfree(send_els->resp);
439 kfree(send_els);
440 }
441
442
443 /**
444 * zfcp_test_link - lightweight link test procedure
445 * @port: port to be tested
446 *
447 * Test status of a link to a remote port using the ELS command ADISC.
448 */
449 int
450 zfcp_test_link(struct zfcp_port *port)
451 {
452 int retval;
453
454 zfcp_port_get(port);
455 retval = zfcp_erp_adisc(port);
456 if (retval != 0) {
457 zfcp_port_put(port);
458 ZFCP_LOG_NORMAL("reopen needed for port 0x%016Lx "
459 "on adapter %s\n ", port->wwpn,
460 zfcp_get_busid_by_port(port));
461 retval = zfcp_erp_port_forced_reopen(port, 0);
462 if (retval != 0) {
463 ZFCP_LOG_NORMAL("reopen of remote port 0x%016Lx "
464 "on adapter %s failed\n", port->wwpn,
465 zfcp_get_busid_by_port(port));
466 retval = -EPERM;
467 }
468 }
469
470 return retval;
471 }
472
473
474 /*
475 * function:
476 *
477 * purpose: called if a port failed to be opened normally
478 * initiates Forced Reopen recovery which is done
479 * asynchronously
480 *
481 * returns: 0 - initiated action successfully
482 * <0 - failed to initiate action
483 */
484 static int
485 zfcp_erp_port_forced_reopen_internal(struct zfcp_port *port, int clear_mask)
486 {
487 int retval;
488 struct zfcp_adapter *adapter = port->adapter;
489
490 debug_text_event(adapter->erp_dbf, 5, "pf_ro");
491 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
492
493 ZFCP_LOG_DEBUG("forced reopen of port 0x%016Lx on adapter %s\n",
494 port->wwpn, zfcp_get_busid_by_port(port));
495
496 zfcp_erp_port_block(port, clear_mask);
497
498 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
499 ZFCP_LOG_DEBUG("skipped forced reopen of failed port 0x%016Lx "
500 "on adapter %s\n", port->wwpn,
501 zfcp_get_busid_by_port(port));
502 debug_text_event(adapter->erp_dbf, 5, "pf_ro_f");
503 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
504 retval = -EIO;
505 goto out;
506 }
507
508 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
509 port->adapter, port, NULL);
510
511 out:
512 return retval;
513 }
514
515 /*
516 * function:
517 *
518 * purpose: Wrappper for zfcp_erp_port_forced_reopen_internal
519 * used to ensure the correct locking
520 *
521 * returns: 0 - initiated action successfully
522 * <0 - failed to initiate action
523 */
524 int
525 zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear_mask)
526 {
527 int retval;
528 unsigned long flags;
529 struct zfcp_adapter *adapter;
530
531 adapter = port->adapter;
532 read_lock_irqsave(&zfcp_data.config_lock, flags);
533 write_lock(&adapter->erp_lock);
534 retval = zfcp_erp_port_forced_reopen_internal(port, clear_mask);
535 write_unlock(&adapter->erp_lock);
536 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
537
538 return retval;
539 }
540
541 /*
542 * function:
543 *
544 * purpose: called if a port is to be opened
545 * initiates Reopen recovery which is done
546 * asynchronously
547 *
548 * returns: 0 - initiated action successfully
549 * <0 - failed to initiate action
550 */
551 static int
552 zfcp_erp_port_reopen_internal(struct zfcp_port *port, int clear_mask)
553 {
554 int retval;
555 struct zfcp_adapter *adapter = port->adapter;
556
557 debug_text_event(adapter->erp_dbf, 5, "p_ro");
558 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
559
560 ZFCP_LOG_DEBUG("reopen of port 0x%016Lx on adapter %s\n",
561 port->wwpn, zfcp_get_busid_by_port(port));
562
563 zfcp_erp_port_block(port, clear_mask);
564
565 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
566 ZFCP_LOG_DEBUG("skipped reopen of failed port 0x%016Lx "
567 "on adapter %s\n", port->wwpn,
568 zfcp_get_busid_by_port(port));
569 debug_text_event(adapter->erp_dbf, 5, "p_ro_f");
570 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
571 /* ensure propagation of failed status to new devices */
572 zfcp_erp_port_failed(port);
573 retval = -EIO;
574 goto out;
575 }
576
577 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
578 port->adapter, port, NULL);
579
580 out:
581 return retval;
582 }
583
584 /**
585 * zfcp_erp_port_reopen - initiate reopen of a remote port
586 * @port: port to be reopened
587 * @clear_mask: specifies flags in port status to be cleared
588 * Return: 0 on success, < 0 on error
589 *
590 * This is a wrappper function for zfcp_erp_port_reopen_internal. It ensures
591 * correct locking. An error recovery task is initiated to do the reopen.
592 * To wait for the completion of the reopen zfcp_erp_wait should be used.
593 */
594 int
595 zfcp_erp_port_reopen(struct zfcp_port *port, int clear_mask)
596 {
597 int retval;
598 unsigned long flags;
599 struct zfcp_adapter *adapter = port->adapter;
600
601 read_lock_irqsave(&zfcp_data.config_lock, flags);
602 write_lock(&adapter->erp_lock);
603 retval = zfcp_erp_port_reopen_internal(port, clear_mask);
604 write_unlock(&adapter->erp_lock);
605 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
606
607 return retval;
608 }
609
610 /*
611 * function:
612 *
613 * purpose: called if a unit is to be opened
614 * initiates Reopen recovery which is done
615 * asynchronously
616 *
617 * returns: 0 - initiated action successfully
618 * <0 - failed to initiate action
619 */
620 static int
621 zfcp_erp_unit_reopen_internal(struct zfcp_unit *unit, int clear_mask)
622 {
623 int retval;
624 struct zfcp_adapter *adapter = unit->port->adapter;
625
626 debug_text_event(adapter->erp_dbf, 5, "u_ro");
627 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
628 ZFCP_LOG_DEBUG("reopen of unit 0x%016Lx on port 0x%016Lx "
629 "on adapter %s\n", unit->fcp_lun,
630 unit->port->wwpn, zfcp_get_busid_by_unit(unit));
631
632 zfcp_erp_unit_block(unit, clear_mask);
633
634 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
635 ZFCP_LOG_DEBUG("skipped reopen of failed unit 0x%016Lx "
636 "on port 0x%016Lx on adapter %s\n",
637 unit->fcp_lun, unit->port->wwpn,
638 zfcp_get_busid_by_unit(unit));
639 debug_text_event(adapter->erp_dbf, 5, "u_ro_f");
640 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
641 sizeof (fcp_lun_t));
642 retval = -EIO;
643 goto out;
644 }
645
646 retval = zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
647 unit->port->adapter, unit->port, unit);
648 out:
649 return retval;
650 }
651
652 /**
653 * zfcp_erp_unit_reopen - initiate reopen of a unit
654 * @unit: unit to be reopened
655 * @clear_mask: specifies flags in unit status to be cleared
656 * Return: 0 on success, < 0 on error
657 *
658 * This is a wrappper for zfcp_erp_unit_reopen_internal. It ensures correct
659 * locking. An error recovery task is initiated to do the reopen.
660 * To wait for the completion of the reopen zfcp_erp_wait should be used.
661 */
662 int
663 zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear_mask)
664 {
665 int retval;
666 unsigned long flags;
667 struct zfcp_adapter *adapter;
668 struct zfcp_port *port;
669
670 port = unit->port;
671 adapter = port->adapter;
672
673 read_lock_irqsave(&zfcp_data.config_lock, flags);
674 write_lock(&adapter->erp_lock);
675 retval = zfcp_erp_unit_reopen_internal(unit, clear_mask);
676 write_unlock(&adapter->erp_lock);
677 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
678
679 return retval;
680 }
681
682 /**
683 * zfcp_erp_adapter_block - mark adapter as blocked, block scsi requests
684 */
685 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int clear_mask)
686 {
687 debug_text_event(adapter->erp_dbf, 6, "a_bl");
688 zfcp_erp_modify_adapter_status(adapter,
689 ZFCP_STATUS_COMMON_UNBLOCKED |
690 clear_mask, ZFCP_CLEAR);
691 }
692
693 /**
694 * zfcp_erp_adapter_unblock - mark adapter as unblocked, allow scsi requests
695 */
696 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
697 {
698 debug_text_event(adapter->erp_dbf, 6, "a_ubl");
699 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
700 }
701
702 /*
703 * function:
704 *
705 * purpose: disable I/O,
706 * return any open requests and clean them up,
707 * aim: no pending and incoming I/O
708 *
709 * returns:
710 */
711 static void
712 zfcp_erp_port_block(struct zfcp_port *port, int clear_mask)
713 {
714 struct zfcp_adapter *adapter = port->adapter;
715
716 debug_text_event(adapter->erp_dbf, 6, "p_bl");
717 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
718 zfcp_erp_modify_port_status(port,
719 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
720 ZFCP_CLEAR);
721 }
722
723 /*
724 * function:
725 *
726 * purpose: enable I/O
727 *
728 * returns:
729 */
730 static void
731 zfcp_erp_port_unblock(struct zfcp_port *port)
732 {
733 struct zfcp_adapter *adapter = port->adapter;
734
735 debug_text_event(adapter->erp_dbf, 6, "p_ubl");
736 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
737 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
738 }
739
740 /*
741 * function:
742 *
743 * purpose: disable I/O,
744 * return any open requests and clean them up,
745 * aim: no pending and incoming I/O
746 *
747 * returns:
748 */
749 static void
750 zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
751 {
752 struct zfcp_adapter *adapter = unit->port->adapter;
753
754 debug_text_event(adapter->erp_dbf, 6, "u_bl");
755 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
756 zfcp_erp_modify_unit_status(unit,
757 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
758 ZFCP_CLEAR);
759 }
760
761 /*
762 * function:
763 *
764 * purpose: enable I/O
765 *
766 * returns:
767 */
768 static void
769 zfcp_erp_unit_unblock(struct zfcp_unit *unit)
770 {
771 struct zfcp_adapter *adapter = unit->port->adapter;
772
773 debug_text_event(adapter->erp_dbf, 6, "u_ubl");
774 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
775 atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
776 }
777
778 static void
779 zfcp_erp_action_ready(struct zfcp_erp_action *erp_action)
780 {
781 struct zfcp_adapter *adapter = erp_action->adapter;
782
783 debug_text_event(adapter->erp_dbf, 4, "a_ar");
784 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
785
786 zfcp_erp_action_to_ready(erp_action);
787 up(&adapter->erp_ready_sem);
788 }
789
790 /*
791 * function:
792 *
793 * purpose:
794 *
795 * returns: <0 erp_action not found in any list
796 * ZFCP_ERP_ACTION_READY erp_action is in ready list
797 * ZFCP_ERP_ACTION_RUNNING erp_action is in running list
798 *
799 * locks: erp_lock must be held
800 */
801 static int
802 zfcp_erp_action_exists(struct zfcp_erp_action *erp_action)
803 {
804 int retval = -EINVAL;
805 struct list_head *entry;
806 struct zfcp_erp_action *entry_erp_action;
807 struct zfcp_adapter *adapter = erp_action->adapter;
808
809 /* search in running list */
810 list_for_each(entry, &adapter->erp_running_head) {
811 entry_erp_action =
812 list_entry(entry, struct zfcp_erp_action, list);
813 if (entry_erp_action == erp_action) {
814 retval = ZFCP_ERP_ACTION_RUNNING;
815 goto out;
816 }
817 }
818 /* search in ready list */
819 list_for_each(entry, &adapter->erp_ready_head) {
820 entry_erp_action =
821 list_entry(entry, struct zfcp_erp_action, list);
822 if (entry_erp_action == erp_action) {
823 retval = ZFCP_ERP_ACTION_READY;
824 goto out;
825 }
826 }
827
828 out:
829 return retval;
830 }
831
832 /*
833 * purpose: checks current status of action (timed out, dismissed, ...)
834 * and does appropriate preparations (dismiss fsf request, ...)
835 *
836 * locks: called under erp_lock (disabled interrupts)
837 *
838 * returns: 0
839 */
840 static int
841 zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *erp_action)
842 {
843 int retval = 0;
844 struct zfcp_fsf_req *fsf_req = NULL;
845 struct zfcp_adapter *adapter = erp_action->adapter;
846
847 if (erp_action->fsf_req) {
848 /* take lock to ensure that request is not deleted meanwhile */
849 spin_lock(&adapter->req_list_lock);
850 if ((!zfcp_reqlist_ismember(adapter,
851 erp_action->fsf_req->req_id)) &&
852 (fsf_req->erp_action == erp_action)) {
853 /* fsf_req still exists */
854 debug_text_event(adapter->erp_dbf, 3, "a_ca_req");
855 debug_event(adapter->erp_dbf, 3, &fsf_req,
856 sizeof (unsigned long));
857 /* dismiss fsf_req of timed out/dismissed erp_action */
858 if (erp_action->status & (ZFCP_STATUS_ERP_DISMISSED |
859 ZFCP_STATUS_ERP_TIMEDOUT)) {
860 debug_text_event(adapter->erp_dbf, 3,
861 "a_ca_disreq");
862 fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
863 }
864 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
865 ZFCP_LOG_NORMAL("error: erp step timed out "
866 "(action=%d, fsf_req=%p)\n ",
867 erp_action->action,
868 erp_action->fsf_req);
869 }
870 /*
871 * If fsf_req is neither dismissed nor completed
872 * then keep it running asynchronously and don't mess
873 * with the association of erp_action and fsf_req.
874 */
875 if (fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED |
876 ZFCP_STATUS_FSFREQ_DISMISSED)) {
877 /* forget about association between fsf_req
878 and erp_action */
879 fsf_req->erp_action = NULL;
880 erp_action->fsf_req = NULL;
881 }
882 } else {
883 debug_text_event(adapter->erp_dbf, 3, "a_ca_gonereq");
884 /*
885 * even if this fsf_req has gone, forget about
886 * association between erp_action and fsf_req
887 */
888 erp_action->fsf_req = NULL;
889 }
890 spin_unlock(&adapter->req_list_lock);
891 } else
892 debug_text_event(adapter->erp_dbf, 3, "a_ca_noreq");
893
894 return retval;
895 }
896
897 /**
898 * zfcp_erp_async_handler_nolock - complete erp_action
899 *
900 * Used for normal completion, time-out, dismissal and failure after
901 * low memory condition.
902 */
903 static void zfcp_erp_async_handler_nolock(struct zfcp_erp_action *erp_action,
904 unsigned long set_mask)
905 {
906 struct zfcp_adapter *adapter = erp_action->adapter;
907
908 if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
909 debug_text_event(adapter->erp_dbf, 2, "a_asyh_ex");
910 debug_event(adapter->erp_dbf, 2, &erp_action->action,
911 sizeof (int));
912 if (!(set_mask & ZFCP_STATUS_ERP_TIMEDOUT))
913 del_timer(&erp_action->timer);
914 erp_action->status |= set_mask;
915 zfcp_erp_action_ready(erp_action);
916 } else {
917 /* action is ready or gone - nothing to do */
918 debug_text_event(adapter->erp_dbf, 3, "a_asyh_gone");
919 debug_event(adapter->erp_dbf, 3, &erp_action->action,
920 sizeof (int));
921 }
922 }
923
924 /**
925 * zfcp_erp_async_handler - wrapper for erp_async_handler_nolock w/ locking
926 */
927 void zfcp_erp_async_handler(struct zfcp_erp_action *erp_action,
928 unsigned long set_mask)
929 {
930 struct zfcp_adapter *adapter = erp_action->adapter;
931 unsigned long flags;
932
933 write_lock_irqsave(&adapter->erp_lock, flags);
934 zfcp_erp_async_handler_nolock(erp_action, set_mask);
935 write_unlock_irqrestore(&adapter->erp_lock, flags);
936 }
937
938 /*
939 * purpose: is called for erp_action which was slept waiting for
940 * memory becoming avaliable,
941 * will trigger that this action will be continued
942 */
943 static void
944 zfcp_erp_memwait_handler(unsigned long data)
945 {
946 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
947 struct zfcp_adapter *adapter = erp_action->adapter;
948
949 debug_text_event(adapter->erp_dbf, 2, "a_mwh");
950 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
951
952 zfcp_erp_async_handler(erp_action, 0);
953 }
954
955 /*
956 * purpose: is called if an asynchronous erp step timed out,
957 * action gets an appropriate flag and will be processed
958 * accordingly
959 */
960 static void
961 zfcp_erp_timeout_handler(unsigned long data)
962 {
963 struct zfcp_erp_action *erp_action = (struct zfcp_erp_action *) data;
964 struct zfcp_adapter *adapter = erp_action->adapter;
965
966 debug_text_event(adapter->erp_dbf, 2, "a_th");
967 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
968
969 zfcp_erp_async_handler(erp_action, ZFCP_STATUS_ERP_TIMEDOUT);
970 }
971
972 /**
973 * zfcp_erp_action_dismiss - dismiss an erp_action
974 *
975 * adapter->erp_lock must be held
976 *
977 * Dismissal of an erp_action is usually required if an erp_action of
978 * higher priority is generated.
979 */
980 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *erp_action)
981 {
982 struct zfcp_adapter *adapter = erp_action->adapter;
983
984 debug_text_event(adapter->erp_dbf, 2, "a_adis");
985 debug_event(adapter->erp_dbf, 2, &erp_action->action, sizeof (int));
986
987 zfcp_erp_async_handler_nolock(erp_action, ZFCP_STATUS_ERP_DISMISSED);
988 }
989
990 int
991 zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
992 {
993 int retval = 0;
994
995 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
996
997 retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
998 if (retval < 0) {
999 ZFCP_LOG_NORMAL("error: creation of erp thread failed for "
1000 "adapter %s\n",
1001 zfcp_get_busid_by_adapter(adapter));
1002 debug_text_event(adapter->erp_dbf, 5, "a_thset_fail");
1003 } else {
1004 wait_event(adapter->erp_thread_wqh,
1005 atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1006 &adapter->status));
1007 debug_text_event(adapter->erp_dbf, 5, "a_thset_ok");
1008 }
1009
1010 return (retval < 0);
1011 }
1012
1013 /*
1014 * function:
1015 *
1016 * purpose:
1017 *
1018 * returns:
1019 *
1020 * context: process (i.e. proc-fs or rmmod/insmod)
1021 *
1022 * note: The caller of this routine ensures that the specified
1023 * adapter has been shut down and that this operation
1024 * has been completed. Thus, there are no pending erp_actions
1025 * which would need to be handled here.
1026 */
1027 int
1028 zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1029 {
1030 int retval = 0;
1031
1032 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1033 up(&adapter->erp_ready_sem);
1034
1035 wait_event(adapter->erp_thread_wqh,
1036 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
1037 &adapter->status));
1038
1039 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1040 &adapter->status);
1041
1042 debug_text_event(adapter->erp_dbf, 5, "a_thki_ok");
1043
1044 return retval;
1045 }
1046
1047 /*
1048 * purpose: is run as a kernel thread,
1049 * goes through list of error recovery actions of associated adapter
1050 * and delegates single action to execution
1051 *
1052 * returns: 0
1053 */
1054 static int
1055 zfcp_erp_thread(void *data)
1056 {
1057 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1058 struct list_head *next;
1059 struct zfcp_erp_action *erp_action;
1060 unsigned long flags;
1061
1062 daemonize("zfcperp%s", zfcp_get_busid_by_adapter(adapter));
1063 /* Block all signals */
1064 siginitsetinv(&current->blocked, 0);
1065 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1066 debug_text_event(adapter->erp_dbf, 5, "a_th_run");
1067 wake_up(&adapter->erp_thread_wqh);
1068
1069 while (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1070 &adapter->status)) {
1071
1072 write_lock_irqsave(&adapter->erp_lock, flags);
1073 next = adapter->erp_ready_head.prev;
1074 write_unlock_irqrestore(&adapter->erp_lock, flags);
1075
1076 if (next != &adapter->erp_ready_head) {
1077 erp_action =
1078 list_entry(next, struct zfcp_erp_action, list);
1079 /*
1080 * process action (incl. [re]moving it
1081 * from 'ready' queue)
1082 */
1083 zfcp_erp_strategy(erp_action);
1084 }
1085
1086 /*
1087 * sleep as long as there is nothing to do, i.e.
1088 * no action in 'ready' queue to be processed and
1089 * thread is not to be killed
1090 */
1091 down_interruptible(&adapter->erp_ready_sem);
1092 debug_text_event(adapter->erp_dbf, 5, "a_th_woken");
1093 }
1094
1095 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1096 debug_text_event(adapter->erp_dbf, 5, "a_th_stop");
1097 wake_up(&adapter->erp_thread_wqh);
1098
1099 return 0;
1100 }
1101
1102 /*
1103 * function:
1104 *
1105 * purpose: drives single error recovery action and schedules higher and
1106 * subordinate actions, if necessary
1107 *
1108 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
1109 * ZFCP_ERP_SUCCEEDED - action finished successfully (deqd)
1110 * ZFCP_ERP_FAILED - action finished unsuccessfully (deqd)
1111 * ZFCP_ERP_EXIT - action finished (dequeued), offline
1112 * ZFCP_ERP_DISMISSED - action canceled (dequeued)
1113 */
1114 static int
1115 zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1116 {
1117 int retval = 0;
1118 struct zfcp_adapter *adapter = erp_action->adapter;
1119 struct zfcp_port *port = erp_action->port;
1120 struct zfcp_unit *unit = erp_action->unit;
1121 int action = erp_action->action;
1122 u32 status = erp_action->status;
1123 unsigned long flags;
1124
1125 /* serialise dismissing, timing out, moving, enqueueing */
1126 read_lock_irqsave(&zfcp_data.config_lock, flags);
1127 write_lock(&adapter->erp_lock);
1128
1129 /* dequeue dismissed action and leave, if required */
1130 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1131 if (retval == ZFCP_ERP_DISMISSED) {
1132 debug_text_event(adapter->erp_dbf, 4, "a_st_dis1");
1133 goto unlock;
1134 }
1135
1136 /*
1137 * move action to 'running' queue before processing it
1138 * (to avoid a race condition regarding moving the
1139 * action to the 'running' queue and back)
1140 */
1141 zfcp_erp_action_to_running(erp_action);
1142
1143 /*
1144 * try to process action as far as possible,
1145 * no lock to allow for blocking operations (kmalloc, qdio, ...),
1146 * afterwards the lock is required again for the following reasons:
1147 * - dequeueing of finished action and enqueueing of
1148 * follow-up actions must be atomic so that any other
1149 * reopen-routine does not believe there is nothing to do
1150 * and that it is safe to enqueue something else,
1151 * - we want to force any control thread which is dismissing
1152 * actions to finish this before we decide about
1153 * necessary steps to be taken here further
1154 */
1155 write_unlock(&adapter->erp_lock);
1156 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1157 retval = zfcp_erp_strategy_do_action(erp_action);
1158 read_lock_irqsave(&zfcp_data.config_lock, flags);
1159 write_lock(&adapter->erp_lock);
1160
1161 /*
1162 * check for dismissed status again to avoid follow-up actions,
1163 * failing of targets and so on for dismissed actions
1164 */
1165 retval = zfcp_erp_strategy_check_action(erp_action, retval);
1166
1167 switch (retval) {
1168 case ZFCP_ERP_DISMISSED:
1169 /* leave since this action has ridden to its ancestors */
1170 debug_text_event(adapter->erp_dbf, 6, "a_st_dis2");
1171 goto unlock;
1172 case ZFCP_ERP_NOMEM:
1173 /* no memory to continue immediately, let it sleep */
1174 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1175 ++adapter->erp_low_mem_count;
1176 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1177 }
1178 /* This condition is true if there is no memory available
1179 for any erp_action on this adapter. This implies that there
1180 are no elements in the memory pool(s) left for erp_actions.
1181 This might happen if an erp_action that used a memory pool
1182 element was timed out.
1183 */
1184 if (adapter->erp_total_count == adapter->erp_low_mem_count) {
1185 debug_text_event(adapter->erp_dbf, 3, "a_st_lowmem");
1186 ZFCP_LOG_NORMAL("error: no mempool elements available, "
1187 "restarting I/O on adapter %s "
1188 "to free mempool\n",
1189 zfcp_get_busid_by_adapter(adapter));
1190 zfcp_erp_adapter_reopen_internal(adapter, 0);
1191 } else {
1192 debug_text_event(adapter->erp_dbf, 2, "a_st_memw");
1193 retval = zfcp_erp_strategy_memwait(erp_action);
1194 }
1195 goto unlock;
1196 case ZFCP_ERP_CONTINUES:
1197 /* leave since this action runs asynchronously */
1198 debug_text_event(adapter->erp_dbf, 6, "a_st_cont");
1199 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1200 --adapter->erp_low_mem_count;
1201 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1202 }
1203 goto unlock;
1204 }
1205 /* ok, finished action (whatever its result is) */
1206
1207 /* check for unrecoverable targets */
1208 retval = zfcp_erp_strategy_check_target(erp_action, retval);
1209
1210 /* action must be dequeued (here to allow for further ones) */
1211 zfcp_erp_action_dequeue(erp_action);
1212
1213 /*
1214 * put this target through the erp mill again if someone has
1215 * requested to change the status of a target being online
1216 * to offline or the other way around
1217 * (old retval is preserved if nothing has to be done here)
1218 */
1219 retval = zfcp_erp_strategy_statechange(action, status, adapter,
1220 port, unit, retval);
1221
1222 /*
1223 * leave if target is in permanent error state or if
1224 * action is repeated in order to process state change
1225 */
1226 if (retval == ZFCP_ERP_EXIT) {
1227 debug_text_event(adapter->erp_dbf, 2, "a_st_exit");
1228 goto unlock;
1229 }
1230
1231 /* trigger follow up actions */
1232 zfcp_erp_strategy_followup_actions(action, adapter, port, unit, retval);
1233
1234 unlock:
1235 write_unlock(&adapter->erp_lock);
1236 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1237
1238 if (retval != ZFCP_ERP_CONTINUES)
1239 zfcp_erp_action_cleanup(action, adapter, port, unit, retval);
1240
1241 /*
1242 * a few tasks remain when the erp queues are empty
1243 * (don't do that if the last action evaluated was dismissed
1244 * since this clearly indicates that there is more to come) :
1245 * - close the name server port if it is open yet
1246 * (enqueues another [probably] final action)
1247 * - otherwise, wake up whoever wants to be woken when we are
1248 * done with erp
1249 */
1250 if (retval != ZFCP_ERP_DISMISSED)
1251 zfcp_erp_strategy_check_queues(adapter);
1252
1253 debug_text_event(adapter->erp_dbf, 6, "a_st_done");
1254
1255 return retval;
1256 }
1257
1258 /*
1259 * function:
1260 *
1261 * purpose:
1262 *
1263 * returns: ZFCP_ERP_DISMISSED - if action has been dismissed
1264 * retval - otherwise
1265 */
1266 static int
1267 zfcp_erp_strategy_check_action(struct zfcp_erp_action *erp_action, int retval)
1268 {
1269 struct zfcp_adapter *adapter = erp_action->adapter;
1270
1271 zfcp_erp_strategy_check_fsfreq(erp_action);
1272
1273 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1274 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1275 debug_text_event(adapter->erp_dbf, 3, "a_stcd_dis");
1276 zfcp_erp_action_dequeue(erp_action);
1277 retval = ZFCP_ERP_DISMISSED;
1278 } else
1279 debug_text_event(adapter->erp_dbf, 5, "a_stcd_nodis");
1280
1281 return retval;
1282 }
1283
1284 static int
1285 zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1286 {
1287 int retval = ZFCP_ERP_FAILED;
1288 struct zfcp_adapter *adapter = erp_action->adapter;
1289
1290 /*
1291 * try to execute/continue action as far as possible,
1292 * note: no lock in subsequent strategy routines
1293 * (this allows these routine to call schedule, e.g.
1294 * kmalloc with such flags or qdio_initialize & friends)
1295 * Note: in case of timeout, the seperate strategies will fail
1296 * anyhow. No need for a special action. Even worse, a nameserver
1297 * failure would not wake up waiting ports without the call.
1298 */
1299 switch (erp_action->action) {
1300
1301 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1302 retval = zfcp_erp_adapter_strategy(erp_action);
1303 break;
1304
1305 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1306 retval = zfcp_erp_port_forced_strategy(erp_action);
1307 break;
1308
1309 case ZFCP_ERP_ACTION_REOPEN_PORT:
1310 retval = zfcp_erp_port_strategy(erp_action);
1311 break;
1312
1313 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1314 retval = zfcp_erp_unit_strategy(erp_action);
1315 break;
1316
1317 default:
1318 debug_text_exception(adapter->erp_dbf, 1, "a_stda_bug");
1319 debug_event(adapter->erp_dbf, 1, &erp_action->action,
1320 sizeof (int));
1321 ZFCP_LOG_NORMAL("bug: unknown erp action requested on "
1322 "adapter %s (action=%d)\n",
1323 zfcp_get_busid_by_adapter(erp_action->adapter),
1324 erp_action->action);
1325 }
1326
1327 return retval;
1328 }
1329
1330 /*
1331 * function:
1332 *
1333 * purpose: triggers retry of this action after a certain amount of time
1334 * by means of timer provided by erp_action
1335 *
1336 * returns: ZFCP_ERP_CONTINUES - erp_action sleeps in erp running queue
1337 */
1338 static int
1339 zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
1340 {
1341 int retval = ZFCP_ERP_CONTINUES;
1342 struct zfcp_adapter *adapter = erp_action->adapter;
1343
1344 debug_text_event(adapter->erp_dbf, 6, "a_mwinit");
1345 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
1346 init_timer(&erp_action->timer);
1347 erp_action->timer.function = zfcp_erp_memwait_handler;
1348 erp_action->timer.data = (unsigned long) erp_action;
1349 erp_action->timer.expires = jiffies + ZFCP_ERP_MEMWAIT_TIMEOUT;
1350 add_timer(&erp_action->timer);
1351
1352 return retval;
1353 }
1354
1355 /*
1356 * function: zfcp_erp_adapter_failed
1357 *
1358 * purpose: sets the adapter and all underlying devices to ERP_FAILED
1359 *
1360 */
1361 void
1362 zfcp_erp_adapter_failed(struct zfcp_adapter *adapter)
1363 {
1364 zfcp_erp_modify_adapter_status(adapter,
1365 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1366 ZFCP_LOG_NORMAL("adapter erp failed on adapter %s\n",
1367 zfcp_get_busid_by_adapter(adapter));
1368 debug_text_event(adapter->erp_dbf, 2, "a_afail");
1369 }
1370
1371 /*
1372 * function: zfcp_erp_port_failed
1373 *
1374 * purpose: sets the port and all underlying devices to ERP_FAILED
1375 *
1376 */
1377 void
1378 zfcp_erp_port_failed(struct zfcp_port *port)
1379 {
1380 zfcp_erp_modify_port_status(port,
1381 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1382
1383 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1384 ZFCP_LOG_NORMAL("port erp failed (adapter %s, "
1385 "port d_id=0x%08x)\n",
1386 zfcp_get_busid_by_port(port), port->d_id);
1387 else
1388 ZFCP_LOG_NORMAL("port erp failed (adapter %s, wwpn=0x%016Lx)\n",
1389 zfcp_get_busid_by_port(port), port->wwpn);
1390
1391 debug_text_event(port->adapter->erp_dbf, 2, "p_pfail");
1392 debug_event(port->adapter->erp_dbf, 2, &port->wwpn, sizeof (wwn_t));
1393 }
1394
1395 /*
1396 * function: zfcp_erp_unit_failed
1397 *
1398 * purpose: sets the unit to ERP_FAILED
1399 *
1400 */
1401 void
1402 zfcp_erp_unit_failed(struct zfcp_unit *unit)
1403 {
1404 zfcp_erp_modify_unit_status(unit,
1405 ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1406
1407 ZFCP_LOG_NORMAL("unit erp failed on unit 0x%016Lx on port 0x%016Lx "
1408 " on adapter %s\n", unit->fcp_lun,
1409 unit->port->wwpn, zfcp_get_busid_by_unit(unit));
1410 debug_text_event(unit->port->adapter->erp_dbf, 2, "u_ufail");
1411 debug_event(unit->port->adapter->erp_dbf, 2,
1412 &unit->fcp_lun, sizeof (fcp_lun_t));
1413 }
1414
1415 /*
1416 * function: zfcp_erp_strategy_check_target
1417 *
1418 * purpose: increments the erp action count on the device currently in
1419 * recovery if the action failed or resets the count in case of
1420 * success. If a maximum count is exceeded the device is marked
1421 * as ERP_FAILED.
1422 * The 'blocked' state of a target which has been recovered
1423 * successfully is reset.
1424 *
1425 * returns: ZFCP_ERP_CONTINUES - action continues (not considered)
1426 * ZFCP_ERP_SUCCEEDED - action finished successfully
1427 * ZFCP_ERP_EXIT - action failed and will not continue
1428 */
1429 static int
1430 zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action, int result)
1431 {
1432 struct zfcp_adapter *adapter = erp_action->adapter;
1433 struct zfcp_port *port = erp_action->port;
1434 struct zfcp_unit *unit = erp_action->unit;
1435
1436 debug_text_event(adapter->erp_dbf, 5, "a_stct_norm");
1437 debug_event(adapter->erp_dbf, 5, &erp_action->action, sizeof (int));
1438 debug_event(adapter->erp_dbf, 5, &result, sizeof (int));
1439
1440 switch (erp_action->action) {
1441
1442 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1443 result = zfcp_erp_strategy_check_unit(unit, result);
1444 break;
1445
1446 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1447 case ZFCP_ERP_ACTION_REOPEN_PORT:
1448 result = zfcp_erp_strategy_check_port(port, result);
1449 break;
1450
1451 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1452 result = zfcp_erp_strategy_check_adapter(adapter, result);
1453 break;
1454 }
1455
1456 return result;
1457 }
1458
1459 static int
1460 zfcp_erp_strategy_statechange(int action,
1461 u32 status,
1462 struct zfcp_adapter *adapter,
1463 struct zfcp_port *port,
1464 struct zfcp_unit *unit, int retval)
1465 {
1466 debug_text_event(adapter->erp_dbf, 3, "a_stsc");
1467 debug_event(adapter->erp_dbf, 3, &action, sizeof (int));
1468
1469 switch (action) {
1470
1471 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1472 if (zfcp_erp_strategy_statechange_detected(&adapter->status,
1473 status)) {
1474 zfcp_erp_adapter_reopen_internal(adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
1475 retval = ZFCP_ERP_EXIT;
1476 }
1477 break;
1478
1479 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1480 case ZFCP_ERP_ACTION_REOPEN_PORT:
1481 if (zfcp_erp_strategy_statechange_detected(&port->status,
1482 status)) {
1483 zfcp_erp_port_reopen_internal(port, ZFCP_STATUS_COMMON_ERP_FAILED);
1484 retval = ZFCP_ERP_EXIT;
1485 }
1486 break;
1487
1488 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1489 if (zfcp_erp_strategy_statechange_detected(&unit->status,
1490 status)) {
1491 zfcp_erp_unit_reopen_internal(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
1492 retval = ZFCP_ERP_EXIT;
1493 }
1494 break;
1495 }
1496
1497 return retval;
1498 }
1499
1500 static inline int
1501 zfcp_erp_strategy_statechange_detected(atomic_t * target_status, u32 erp_status)
1502 {
1503 return
1504 /* take it online */
1505 (atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1506 (ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status)) ||
1507 /* take it offline */
1508 (!atomic_test_mask(ZFCP_STATUS_COMMON_RUNNING, target_status) &&
1509 !(ZFCP_STATUS_ERP_CLOSE_ONLY & erp_status));
1510 }
1511
1512 static int
1513 zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
1514 {
1515 debug_text_event(unit->port->adapter->erp_dbf, 5, "u_stct");
1516 debug_event(unit->port->adapter->erp_dbf, 5, &unit->fcp_lun,
1517 sizeof (fcp_lun_t));
1518
1519 switch (result) {
1520 case ZFCP_ERP_SUCCEEDED :
1521 atomic_set(&unit->erp_counter, 0);
1522 zfcp_erp_unit_unblock(unit);
1523 break;
1524 case ZFCP_ERP_FAILED :
1525 atomic_inc(&unit->erp_counter);
1526 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS)
1527 zfcp_erp_unit_failed(unit);
1528 break;
1529 case ZFCP_ERP_EXIT :
1530 /* nothing */
1531 break;
1532 }
1533
1534 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &unit->status)) {
1535 zfcp_erp_unit_block(unit, 0); /* for ZFCP_ERP_SUCCEEDED */
1536 result = ZFCP_ERP_EXIT;
1537 }
1538
1539 return result;
1540 }
1541
1542 static int
1543 zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1544 {
1545 debug_text_event(port->adapter->erp_dbf, 5, "p_stct");
1546 debug_event(port->adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
1547
1548 switch (result) {
1549 case ZFCP_ERP_SUCCEEDED :
1550 atomic_set(&port->erp_counter, 0);
1551 zfcp_erp_port_unblock(port);
1552 break;
1553 case ZFCP_ERP_FAILED :
1554 atomic_inc(&port->erp_counter);
1555 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS)
1556 zfcp_erp_port_failed(port);
1557 break;
1558 case ZFCP_ERP_EXIT :
1559 /* nothing */
1560 break;
1561 }
1562
1563 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
1564 zfcp_erp_port_block(port, 0); /* for ZFCP_ERP_SUCCEEDED */
1565 result = ZFCP_ERP_EXIT;
1566 }
1567
1568 return result;
1569 }
1570
1571 static int
1572 zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter, int result)
1573 {
1574 debug_text_event(adapter->erp_dbf, 5, "a_stct");
1575
1576 switch (result) {
1577 case ZFCP_ERP_SUCCEEDED :
1578 atomic_set(&adapter->erp_counter, 0);
1579 zfcp_erp_adapter_unblock(adapter);
1580 break;
1581 case ZFCP_ERP_FAILED :
1582 atomic_inc(&adapter->erp_counter);
1583 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS)
1584 zfcp_erp_adapter_failed(adapter);
1585 break;
1586 case ZFCP_ERP_EXIT :
1587 /* nothing */
1588 break;
1589 }
1590
1591 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
1592 zfcp_erp_adapter_block(adapter, 0); /* for ZFCP_ERP_SUCCEEDED */
1593 result = ZFCP_ERP_EXIT;
1594 }
1595
1596 return result;
1597 }
1598
1599 /*
1600 * function:
1601 *
1602 * purpose: remaining things in good cases,
1603 * escalation in bad cases
1604 *
1605 * returns:
1606 */
1607 static int
1608 zfcp_erp_strategy_followup_actions(int action,
1609 struct zfcp_adapter *adapter,
1610 struct zfcp_port *port,
1611 struct zfcp_unit *unit, int status)
1612 {
1613 debug_text_event(adapter->erp_dbf, 5, "a_stfol");
1614 debug_event(adapter->erp_dbf, 5, &action, sizeof (int));
1615
1616 /* initiate follow-up actions depending on success of finished action */
1617 switch (action) {
1618
1619 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1620 if (status == ZFCP_ERP_SUCCEEDED)
1621 zfcp_erp_port_reopen_all_internal(adapter, 0);
1622 else
1623 zfcp_erp_adapter_reopen_internal(adapter, 0);
1624 break;
1625
1626 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1627 if (status == ZFCP_ERP_SUCCEEDED)
1628 zfcp_erp_port_reopen_internal(port, 0);
1629 else
1630 zfcp_erp_adapter_reopen_internal(adapter, 0);
1631 break;
1632
1633 case ZFCP_ERP_ACTION_REOPEN_PORT:
1634 if (status == ZFCP_ERP_SUCCEEDED)
1635 zfcp_erp_unit_reopen_all_internal(port, 0);
1636 else
1637 zfcp_erp_port_forced_reopen_internal(port, 0);
1638 break;
1639
1640 case ZFCP_ERP_ACTION_REOPEN_UNIT:
1641 if (status == ZFCP_ERP_SUCCEEDED) ; /* no further action */
1642 else
1643 zfcp_erp_port_reopen_internal(unit->port, 0);
1644 break;
1645 }
1646
1647 return 0;
1648 }
1649
1650 static int
1651 zfcp_erp_strategy_check_queues(struct zfcp_adapter *adapter)
1652 {
1653 unsigned long flags;
1654
1655 read_lock_irqsave(&zfcp_data.config_lock, flags);
1656 read_lock(&adapter->erp_lock);
1657 if (list_empty(&adapter->erp_ready_head) &&
1658 list_empty(&adapter->erp_running_head)) {
1659 debug_text_event(adapter->erp_dbf, 4, "a_cq_wake");
1660 atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1661 &adapter->status);
1662 wake_up(&adapter->erp_done_wqh);
1663 } else
1664 debug_text_event(adapter->erp_dbf, 5, "a_cq_notempty");
1665 read_unlock(&adapter->erp_lock);
1666 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1667
1668 return 0;
1669 }
1670
1671 /**
1672 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1673 * @adapter: adapter for which to wait for completion of its error recovery
1674 * Return: 0
1675 */
1676 int
1677 zfcp_erp_wait(struct zfcp_adapter *adapter)
1678 {
1679 int retval = 0;
1680
1681 wait_event(adapter->erp_done_wqh,
1682 !atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
1683 &adapter->status));
1684
1685 return retval;
1686 }
1687
1688 void
1689 zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter,
1690 u32 mask, int set_or_clear)
1691 {
1692 struct zfcp_port *port;
1693 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1694
1695 if (set_or_clear == ZFCP_SET) {
1696 atomic_set_mask(mask, &adapter->status);
1697 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_s");
1698 } else {
1699 atomic_clear_mask(mask, &adapter->status);
1700 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1701 atomic_set(&adapter->erp_counter, 0);
1702 debug_text_event(adapter->erp_dbf, 3, "a_mod_as_c");
1703 }
1704 debug_event(adapter->erp_dbf, 3, &mask, sizeof (u32));
1705
1706 /* Deal with all underlying devices, only pass common_mask */
1707 if (common_mask)
1708 list_for_each_entry(port, &adapter->port_list_head, list)
1709 zfcp_erp_modify_port_status(port, common_mask,
1710 set_or_clear);
1711 }
1712
1713 /*
1714 * function: zfcp_erp_modify_port_status
1715 *
1716 * purpose: sets the port and all underlying devices to ERP_FAILED
1717 *
1718 */
1719 void
1720 zfcp_erp_modify_port_status(struct zfcp_port *port, u32 mask, int set_or_clear)
1721 {
1722 struct zfcp_unit *unit;
1723 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1724
1725 if (set_or_clear == ZFCP_SET) {
1726 atomic_set_mask(mask, &port->status);
1727 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_s");
1728 } else {
1729 atomic_clear_mask(mask, &port->status);
1730 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1731 atomic_set(&port->erp_counter, 0);
1732 debug_text_event(port->adapter->erp_dbf, 3, "p_mod_ps_c");
1733 }
1734 debug_event(port->adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
1735 debug_event(port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1736
1737 /* Modify status of all underlying devices, only pass common mask */
1738 if (common_mask)
1739 list_for_each_entry(unit, &port->unit_list_head, list)
1740 zfcp_erp_modify_unit_status(unit, common_mask,
1741 set_or_clear);
1742 }
1743
1744 /*
1745 * function: zfcp_erp_modify_unit_status
1746 *
1747 * purpose: sets the unit to ERP_FAILED
1748 *
1749 */
1750 void
1751 zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u32 mask, int set_or_clear)
1752 {
1753 if (set_or_clear == ZFCP_SET) {
1754 atomic_set_mask(mask, &unit->status);
1755 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_s");
1756 } else {
1757 atomic_clear_mask(mask, &unit->status);
1758 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1759 atomic_set(&unit->erp_counter, 0);
1760 }
1761 debug_text_event(unit->port->adapter->erp_dbf, 3, "u_mod_us_c");
1762 }
1763 debug_event(unit->port->adapter->erp_dbf, 3, &unit->fcp_lun,
1764 sizeof (fcp_lun_t));
1765 debug_event(unit->port->adapter->erp_dbf, 3, &mask, sizeof (u32));
1766 }
1767
1768 /*
1769 * function:
1770 *
1771 * purpose: Wrappper for zfcp_erp_port_reopen_all_internal
1772 * used to ensure the correct locking
1773 *
1774 * returns: 0 - initiated action successfully
1775 * <0 - failed to initiate action
1776 */
1777 int
1778 zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter, int clear_mask)
1779 {
1780 int retval;
1781 unsigned long flags;
1782
1783 read_lock_irqsave(&zfcp_data.config_lock, flags);
1784 write_lock(&adapter->erp_lock);
1785 retval = zfcp_erp_port_reopen_all_internal(adapter, clear_mask);
1786 write_unlock(&adapter->erp_lock);
1787 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1788
1789 return retval;
1790 }
1791
1792 static int
1793 zfcp_erp_port_reopen_all_internal(struct zfcp_adapter *adapter, int clear_mask)
1794 {
1795 int retval = 0;
1796 struct zfcp_port *port;
1797
1798 list_for_each_entry(port, &adapter->port_list_head, list)
1799 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
1800 zfcp_erp_port_reopen_internal(port, clear_mask);
1801
1802 return retval;
1803 }
1804
1805 /*
1806 * function:
1807 *
1808 * purpose:
1809 *
1810 * returns: FIXME
1811 */
1812 static int
1813 zfcp_erp_unit_reopen_all_internal(struct zfcp_port *port, int clear_mask)
1814 {
1815 int retval = 0;
1816 struct zfcp_unit *unit;
1817
1818 list_for_each_entry(unit, &port->unit_list_head, list)
1819 zfcp_erp_unit_reopen_internal(unit, clear_mask);
1820
1821 return retval;
1822 }
1823
1824 /*
1825 * function:
1826 *
1827 * purpose: this routine executes the 'Reopen Adapter' action
1828 * (the entire action is processed synchronously, since
1829 * there are no actions which might be run concurrently
1830 * per definition)
1831 *
1832 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1833 * ZFCP_ERP_FAILED - action finished unsuccessfully
1834 */
1835 static int
1836 zfcp_erp_adapter_strategy(struct zfcp_erp_action *erp_action)
1837 {
1838 int retval;
1839 struct zfcp_adapter *adapter = erp_action->adapter;
1840
1841 retval = zfcp_erp_adapter_strategy_close(erp_action);
1842 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1843 retval = ZFCP_ERP_EXIT;
1844 else
1845 retval = zfcp_erp_adapter_strategy_open(erp_action);
1846
1847 debug_text_event(adapter->erp_dbf, 3, "a_ast/ret");
1848 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
1849 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
1850
1851 if (retval == ZFCP_ERP_FAILED) {
1852 ZFCP_LOG_INFO("Waiting to allow the adapter %s "
1853 "to recover itself\n",
1854 zfcp_get_busid_by_adapter(adapter));
1855 msleep(jiffies_to_msecs(ZFCP_TYPE2_RECOVERY_TIME));
1856 }
1857
1858 return retval;
1859 }
1860
1861 /*
1862 * function:
1863 *
1864 * purpose:
1865 *
1866 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1867 * ZFCP_ERP_FAILED - action finished unsuccessfully
1868 */
1869 static int
1870 zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *erp_action)
1871 {
1872 int retval;
1873
1874 atomic_set_mask(ZFCP_STATUS_COMMON_CLOSING,
1875 &erp_action->adapter->status);
1876 retval = zfcp_erp_adapter_strategy_generic(erp_action, 1);
1877 atomic_clear_mask(ZFCP_STATUS_COMMON_CLOSING,
1878 &erp_action->adapter->status);
1879
1880 return retval;
1881 }
1882
1883 /*
1884 * function:
1885 *
1886 * purpose:
1887 *
1888 * returns: ZFCP_ERP_SUCCEEDED - action finished successfully
1889 * ZFCP_ERP_FAILED - action finished unsuccessfully
1890 */
1891 static int
1892 zfcp_erp_adapter_strategy_open(struct zfcp_erp_action *erp_action)
1893 {
1894 int retval;
1895
1896 atomic_set_mask(ZFCP_STATUS_COMMON_OPENING,
1897 &erp_action->adapter->status);
1898 retval = zfcp_erp_adapter_strategy_generic(erp_action, 0);
1899 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING,
1900 &erp_action->adapter->status);
1901
1902 return retval;
1903 }
1904
1905 /*
1906 * function: zfcp_register_adapter
1907 *
1908 * purpose: allocate the irq associated with this devno and register
1909 * the FSF adapter with the SCSI stack
1910 *
1911 * returns:
1912 */
1913 static int
1914 zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *erp_action, int close)
1915 {
1916 int retval = ZFCP_ERP_SUCCEEDED;
1917
1918 if (close)
1919 goto close_only;
1920
1921 retval = zfcp_erp_adapter_strategy_open_qdio(erp_action);
1922 if (retval != ZFCP_ERP_SUCCEEDED)
1923 goto failed_qdio;
1924
1925 retval = zfcp_erp_adapter_strategy_open_fsf(erp_action);
1926 if (retval != ZFCP_ERP_SUCCEEDED)
1927 goto failed_openfcp;
1928
1929 atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &erp_action->adapter->status);
1930 goto out;
1931
1932 close_only:
1933 atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
1934 &erp_action->adapter->status);
1935
1936 failed_openfcp:
1937 zfcp_erp_adapter_strategy_close_qdio(erp_action);
1938 zfcp_erp_adapter_strategy_close_fsf(erp_action);
1939 failed_qdio:
1940 out:
1941 return retval;
1942 }
1943
1944 /*
1945 * function: zfcp_qdio_init
1946 *
1947 * purpose: setup QDIO operation for specified adapter
1948 *
1949 * returns: 0 - successful setup
1950 * !0 - failed setup
1951 */
1952 int
1953 zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *erp_action)
1954 {
1955 int retval;
1956 int i;
1957 volatile struct qdio_buffer_element *sbale;
1958 struct zfcp_adapter *adapter = erp_action->adapter;
1959
1960 if (atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
1961 ZFCP_LOG_NORMAL("bug: second attempt to set up QDIO on "
1962 "adapter %s\n",
1963 zfcp_get_busid_by_adapter(adapter));
1964 goto failed_sanity;
1965 }
1966
1967 if (qdio_establish(&adapter->qdio_init_data) != 0) {
1968 ZFCP_LOG_INFO("error: establishment of QDIO queues failed "
1969 "on adapter %s\n",
1970 zfcp_get_busid_by_adapter(adapter));
1971 goto failed_qdio_establish;
1972 }
1973 debug_text_event(adapter->erp_dbf, 3, "qdio_est");
1974
1975 if (qdio_activate(adapter->ccw_device, 0) != 0) {
1976 ZFCP_LOG_INFO("error: activation of QDIO queues failed "
1977 "on adapter %s\n",
1978 zfcp_get_busid_by_adapter(adapter));
1979 goto failed_qdio_activate;
1980 }
1981 debug_text_event(adapter->erp_dbf, 3, "qdio_act");
1982
1983 /*
1984 * put buffers into response queue,
1985 */
1986 for (i = 0; i < QDIO_MAX_BUFFERS_PER_Q; i++) {
1987 sbale = &(adapter->response_queue.buffer[i]->element[0]);
1988 sbale->length = 0;
1989 sbale->flags = SBAL_FLAGS_LAST_ENTRY;
1990 sbale->addr = 0;
1991 }
1992
1993 ZFCP_LOG_TRACE("calling do_QDIO on adapter %s (flags=0x%x, "
1994 "queue_no=%i, index_in_queue=%i, count=%i)\n",
1995 zfcp_get_busid_by_adapter(adapter),
1996 QDIO_FLAG_SYNC_INPUT, 0, 0, QDIO_MAX_BUFFERS_PER_Q);
1997
1998 retval = do_QDIO(adapter->ccw_device,
1999 QDIO_FLAG_SYNC_INPUT,
2000 0, 0, QDIO_MAX_BUFFERS_PER_Q, NULL);
2001
2002 if (retval) {
2003 ZFCP_LOG_NORMAL("bug: setup of QDIO failed (retval=%d)\n",
2004 retval);
2005 goto failed_do_qdio;
2006 } else {
2007 adapter->response_queue.free_index = 0;
2008 atomic_set(&adapter->response_queue.free_count, 0);
2009 ZFCP_LOG_DEBUG("%i buffers successfully enqueued to "
2010 "response queue\n", QDIO_MAX_BUFFERS_PER_Q);
2011 }
2012 /* set index of first avalable SBALS / number of available SBALS */
2013 adapter->request_queue.free_index = 0;
2014 atomic_set(&adapter->request_queue.free_count, QDIO_MAX_BUFFERS_PER_Q);
2015 adapter->request_queue.distance_from_int = 0;
2016
2017 /* initialize waitqueue used to wait for free SBALs in requests queue */
2018 init_waitqueue_head(&adapter->request_wq);
2019
2020 /* ok, we did it - skip all cleanups for different failures */
2021 atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
2022 retval = ZFCP_ERP_SUCCEEDED;
2023 goto out;
2024
2025 failed_do_qdio:
2026 /* NOP */
2027
2028 failed_qdio_activate:
2029 debug_text_event(adapter->erp_dbf, 3, "qdio_down1a");
2030 while (qdio_shutdown(adapter->ccw_device,
2031 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
2032 msleep(1000);
2033 debug_text_event(adapter->erp_dbf, 3, "qdio_down1b");
2034
2035 failed_qdio_establish:
2036 failed_sanity:
2037 retval = ZFCP_ERP_FAILED;
2038
2039 out:
2040 return retval;
2041 }
2042
2043 /**
2044 * zfcp_erp_adapter_strategy_close_qdio - close qdio queues for an adapter
2045 */
2046 static void
2047 zfcp_erp_adapter_strategy_close_qdio(struct zfcp_erp_action *erp_action)
2048 {
2049 int first_used;
2050 int used_count;
2051 struct zfcp_adapter *adapter = erp_action->adapter;
2052
2053 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status)) {
2054 ZFCP_LOG_DEBUG("error: attempt to shut down inactive QDIO "
2055 "queues on adapter %s\n",
2056 zfcp_get_busid_by_adapter(adapter));
2057 return;
2058 }
2059
2060 /*
2061 * Get queue_lock and clear QDIOUP flag. Thus it's guaranteed that
2062 * do_QDIO won't be called while qdio_shutdown is in progress.
2063 */
2064 write_lock_irq(&adapter->request_queue.queue_lock);
2065 atomic_clear_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &adapter->status);
2066 write_unlock_irq(&adapter->request_queue.queue_lock);
2067
2068 debug_text_event(adapter->erp_dbf, 3, "qdio_down2a");
2069 while (qdio_shutdown(adapter->ccw_device,
2070 QDIO_FLAG_CLEANUP_USING_CLEAR) == -EINPROGRESS)
2071 msleep(1000);
2072 debug_text_event(adapter->erp_dbf, 3, "qdio_down2b");
2073
2074 /*
2075 * First we had to stop QDIO operation.
2076 * Now it is safe to take the following actions.
2077 */
2078
2079 /* Cleanup only necessary when there are unacknowledged buffers */
2080 if (atomic_read(&adapter->request_queue.free_count)
2081 < QDIO_MAX_BUFFERS_PER_Q) {
2082 first_used = (adapter->request_queue.free_index +
2083 atomic_read(&adapter->request_queue.free_count))
2084 % QDIO_MAX_BUFFERS_PER_Q;
2085 used_count = QDIO_MAX_BUFFERS_PER_Q -
2086 atomic_read(&adapter->request_queue.free_count);
2087 zfcp_qdio_zero_sbals(adapter->request_queue.buffer,
2088 first_used, used_count);
2089 }
2090 adapter->response_queue.free_index = 0;
2091 atomic_set(&adapter->response_queue.free_count, 0);
2092 adapter->request_queue.free_index = 0;
2093 atomic_set(&adapter->request_queue.free_count, 0);
2094 adapter->request_queue.distance_from_int = 0;
2095 }
2096
2097 static int
2098 zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *erp_action)
2099 {
2100 int retval;
2101
2102 retval = zfcp_erp_adapter_strategy_open_fsf_xconfig(erp_action);
2103 if (retval == ZFCP_ERP_FAILED)
2104 return ZFCP_ERP_FAILED;
2105
2106 retval = zfcp_erp_adapter_strategy_open_fsf_xport(erp_action);
2107 if (retval == ZFCP_ERP_FAILED)
2108 return ZFCP_ERP_FAILED;
2109
2110 return zfcp_erp_adapter_strategy_open_fsf_statusread(erp_action);
2111 }
2112
2113 static int
2114 zfcp_erp_adapter_strategy_open_fsf_xconfig(struct zfcp_erp_action *erp_action)
2115 {
2116 int retval = ZFCP_ERP_SUCCEEDED;
2117 int retries;
2118 int sleep = ZFCP_EXCHANGE_CONFIG_DATA_FIRST_SLEEP;
2119 struct zfcp_adapter *adapter = erp_action->adapter;
2120
2121 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
2122
2123 for (retries = ZFCP_EXCHANGE_CONFIG_DATA_RETRIES; retries; retries--) {
2124 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2125 &adapter->status);
2126 ZFCP_LOG_DEBUG("Doing exchange config data\n");
2127 write_lock_irq(&adapter->erp_lock);
2128 zfcp_erp_action_to_running(erp_action);
2129 write_unlock_irq(&adapter->erp_lock);
2130 zfcp_erp_timeout_init(erp_action);
2131 if (zfcp_fsf_exchange_config_data(erp_action)) {
2132 retval = ZFCP_ERP_FAILED;
2133 debug_text_event(adapter->erp_dbf, 5, "a_fstx_xf");
2134 ZFCP_LOG_INFO("error: initiation of exchange of "
2135 "configuration data failed for "
2136 "adapter %s\n",
2137 zfcp_get_busid_by_adapter(adapter));
2138 break;
2139 }
2140 debug_text_event(adapter->erp_dbf, 6, "a_fstx_xok");
2141 ZFCP_LOG_DEBUG("Xchange underway\n");
2142
2143 /*
2144 * Why this works:
2145 * Both the normal completion handler as well as the timeout
2146 * handler will do an 'up' when the 'exchange config data'
2147 * request completes or times out. Thus, the signal to go on
2148 * won't be lost utilizing this semaphore.
2149 * Furthermore, this 'adapter_reopen' action is
2150 * guaranteed to be the only action being there (highest action
2151 * which prevents other actions from being created).
2152 * Resulting from that, the wake signal recognized here
2153 * _must_ be the one belonging to the 'exchange config
2154 * data' request.
2155 */
2156 down(&adapter->erp_ready_sem);
2157 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2158 ZFCP_LOG_INFO("error: exchange of configuration data "
2159 "for adapter %s timed out\n",
2160 zfcp_get_busid_by_adapter(adapter));
2161 break;
2162 }
2163
2164 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
2165 &adapter->status))
2166 break;
2167
2168 ZFCP_LOG_DEBUG("host connection still initialising... "
2169 "waiting and retrying...\n");
2170 /* sleep a little bit before retry */
2171 msleep(jiffies_to_msecs(sleep));
2172 sleep *= 2;
2173 }
2174
2175 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK,
2176 &adapter->status)) {
2177 ZFCP_LOG_INFO("error: exchange of configuration data for "
2178 "adapter %s failed\n",
2179 zfcp_get_busid_by_adapter(adapter));
2180 retval = ZFCP_ERP_FAILED;
2181 }
2182
2183 return retval;
2184 }
2185
2186 static int
2187 zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *erp_action)
2188 {
2189 int ret;
2190 struct zfcp_adapter *adapter;
2191
2192 adapter = erp_action->adapter;
2193 atomic_clear_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status);
2194
2195 write_lock_irq(&adapter->erp_lock);
2196 zfcp_erp_action_to_running(erp_action);
2197 write_unlock_irq(&adapter->erp_lock);
2198
2199 zfcp_erp_timeout_init(erp_action);
2200 ret = zfcp_fsf_exchange_port_data(erp_action, adapter, NULL);
2201 if (ret == -EOPNOTSUPP) {
2202 debug_text_event(adapter->erp_dbf, 3, "a_xport_notsupp");
2203 return ZFCP_ERP_SUCCEEDED;
2204 } else if (ret) {
2205 debug_text_event(adapter->erp_dbf, 3, "a_xport_failed");
2206 return ZFCP_ERP_FAILED;
2207 }
2208 debug_text_event(adapter->erp_dbf, 6, "a_xport_ok");
2209
2210 ret = ZFCP_ERP_SUCCEEDED;
2211 down(&adapter->erp_ready_sem);
2212 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
2213 ZFCP_LOG_INFO("error: exchange port data timed out (adapter "
2214 "%s)\n", zfcp_get_busid_by_adapter(adapter));
2215 ret = ZFCP_ERP_FAILED;
2216 }
2217
2218 /* don't treat as error for the sake of compatibility */
2219 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_XPORT_OK, &adapter->status))
2220 ZFCP_LOG_INFO("warning: exchange port data failed (adapter "
2221 "%s\n", zfcp_get_busid_by_adapter(adapter));
2222
2223 return ret;
2224 }
2225
2226 static int
2227 zfcp_erp_adapter_strategy_open_fsf_statusread(struct zfcp_erp_action
2228 *erp_action)
2229 {
2230 int retval = ZFCP_ERP_SUCCEEDED;
2231 int temp_ret;
2232 struct zfcp_adapter *adapter = erp_action->adapter;
2233 int i;
2234
2235 adapter->status_read_failed = 0;
2236 for (i = 0; i < ZFCP_STATUS_READS_RECOM; i++) {
2237 temp_ret = zfcp_fsf_status_read(adapter, ZFCP_WAIT_FOR_SBAL);
2238 if (temp_ret < 0) {
2239 ZFCP_LOG_INFO("error: set-up of unsolicited status "
2240 "notification failed on adapter %s\n",
2241 zfcp_get_busid_by_adapter(adapter));
2242 retval = ZFCP_ERP_FAILED;
2243 i--;
2244 break;
2245 }
2246 }
2247
2248 return retval;
2249 }
2250
2251 /**
2252 * zfcp_erp_adapter_strategy_close_fsf - stop FSF operations for an adapter
2253 */
2254 static void
2255 zfcp_erp_adapter_strategy_close_fsf(struct zfcp_erp_action *erp_action)
2256 {
2257 struct zfcp_adapter *adapter = erp_action->adapter;
2258
2259 /*
2260 * wake waiting initiators of requests,
2261 * return SCSI commands (with error status),
2262 * clean up all requests (synchronously)
2263 */
2264 zfcp_fsf_req_dismiss_all(adapter);
2265 /* reset FSF request sequence number */
2266 adapter->fsf_req_seq_no = 0;
2267 /* all ports and units are closed */
2268 zfcp_erp_modify_adapter_status(adapter,
2269 ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
2270 }
2271
2272 /*
2273 * function:
2274 *
2275 * purpose: this routine executes the 'Reopen Physical Port' action
2276 *
2277 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2278 * ZFCP_ERP_SUCCEEDED - action finished successfully
2279 * ZFCP_ERP_FAILED - action finished unsuccessfully
2280 */
2281 static int
2282 zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
2283 {
2284 int retval = ZFCP_ERP_FAILED;
2285 struct zfcp_port *port = erp_action->port;
2286 struct zfcp_adapter *adapter = erp_action->adapter;
2287
2288 switch (erp_action->step) {
2289
2290 /*
2291 * FIXME:
2292 * the ULP spec. begs for waiting for oustanding commands
2293 */
2294 case ZFCP_ERP_STEP_UNINITIALIZED:
2295 zfcp_erp_port_strategy_clearstati(port);
2296 /*
2297 * it would be sufficient to test only the normal open flag
2298 * since the phys. open flag cannot be set if the normal
2299 * open flag is unset - however, this is for readabilty ...
2300 */
2301 if (atomic_test_mask((ZFCP_STATUS_PORT_PHYS_OPEN |
2302 ZFCP_STATUS_COMMON_OPEN),
2303 &port->status)) {
2304 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2305 "close physical\n", port->wwpn);
2306 retval =
2307 zfcp_erp_port_forced_strategy_close(erp_action);
2308 } else
2309 retval = ZFCP_ERP_FAILED;
2310 break;
2311
2312 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2313 if (atomic_test_mask(ZFCP_STATUS_PORT_PHYS_OPEN,
2314 &port->status)) {
2315 ZFCP_LOG_DEBUG("close physical failed for port "
2316 "0x%016Lx\n", port->wwpn);
2317 retval = ZFCP_ERP_FAILED;
2318 } else
2319 retval = ZFCP_ERP_SUCCEEDED;
2320 break;
2321 }
2322
2323 debug_text_event(adapter->erp_dbf, 3, "p_pfst/ret");
2324 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2325 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2326 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2327
2328 return retval;
2329 }
2330
2331 /*
2332 * function:
2333 *
2334 * purpose: this routine executes the 'Reopen Port' action
2335 *
2336 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2337 * ZFCP_ERP_SUCCEEDED - action finished successfully
2338 * ZFCP_ERP_FAILED - action finished unsuccessfully
2339 */
2340 static int
2341 zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
2342 {
2343 int retval = ZFCP_ERP_FAILED;
2344 struct zfcp_port *port = erp_action->port;
2345 struct zfcp_adapter *adapter = erp_action->adapter;
2346
2347 switch (erp_action->step) {
2348
2349 /*
2350 * FIXME:
2351 * the ULP spec. begs for waiting for oustanding commands
2352 */
2353 case ZFCP_ERP_STEP_UNINITIALIZED:
2354 zfcp_erp_port_strategy_clearstati(port);
2355 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2356 ZFCP_LOG_DEBUG("port 0x%016Lx is open -> trying "
2357 "close\n", port->wwpn);
2358 retval = zfcp_erp_port_strategy_close(erp_action);
2359 goto out;
2360 } /* else it's already closed, open it */
2361 break;
2362
2363 case ZFCP_ERP_STEP_PORT_CLOSING:
2364 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2365 ZFCP_LOG_DEBUG("close failed for port 0x%016Lx\n",
2366 port->wwpn);
2367 retval = ZFCP_ERP_FAILED;
2368 goto out;
2369 } /* else it's closed now, open it */
2370 break;
2371 }
2372 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2373 retval = ZFCP_ERP_EXIT;
2374 else
2375 retval = zfcp_erp_port_strategy_open(erp_action);
2376
2377 out:
2378 debug_text_event(adapter->erp_dbf, 3, "p_pst/ret");
2379 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof (wwn_t));
2380 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2381 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2382
2383 return retval;
2384 }
2385
2386 static int
2387 zfcp_erp_port_strategy_open(struct zfcp_erp_action *erp_action)
2388 {
2389 int retval;
2390
2391 if (atomic_test_mask(ZFCP_STATUS_PORT_WKA,
2392 &erp_action->port->status))
2393 retval = zfcp_erp_port_strategy_open_nameserver(erp_action);
2394 else
2395 retval = zfcp_erp_port_strategy_open_common(erp_action);
2396
2397 return retval;
2398 }
2399
2400 static int
2401 zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *erp_action)
2402 {
2403 int retval = 0;
2404 struct zfcp_adapter *adapter = erp_action->adapter;
2405 struct zfcp_port *port = erp_action->port;
2406
2407 switch (erp_action->step) {
2408
2409 case ZFCP_ERP_STEP_UNINITIALIZED:
2410 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2411 case ZFCP_ERP_STEP_PORT_CLOSING:
2412 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP) {
2413 if (port->wwpn != adapter->peer_wwpn) {
2414 ZFCP_LOG_NORMAL("Failed to open port 0x%016Lx "
2415 "on adapter %s.\nPeer WWPN "
2416 "0x%016Lx does not match\n",
2417 port->wwpn,
2418 zfcp_get_busid_by_adapter(adapter),
2419 adapter->peer_wwpn);
2420 zfcp_erp_port_failed(port);
2421 retval = ZFCP_ERP_FAILED;
2422 break;
2423 }
2424 port->d_id = adapter->peer_d_id;
2425 atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
2426 retval = zfcp_erp_port_strategy_open_port(erp_action);
2427 break;
2428 }
2429 if (!(adapter->nameserver_port)) {
2430 retval = zfcp_nameserver_enqueue(adapter);
2431 if (retval != 0) {
2432 ZFCP_LOG_NORMAL("error: nameserver port "
2433 "unavailable for adapter %s\n",
2434 zfcp_get_busid_by_adapter(adapter));
2435 retval = ZFCP_ERP_FAILED;
2436 break;
2437 }
2438 }
2439 if (!atomic_test_mask(ZFCP_STATUS_COMMON_UNBLOCKED,
2440 &adapter->nameserver_port->status)) {
2441 ZFCP_LOG_DEBUG("nameserver port is not open -> open "
2442 "nameserver port\n");
2443 /* nameserver port may live again */
2444 atomic_set_mask(ZFCP_STATUS_COMMON_RUNNING,
2445 &adapter->nameserver_port->status);
2446 if (zfcp_erp_port_reopen(adapter->nameserver_port, 0)
2447 >= 0) {
2448 erp_action->step =
2449 ZFCP_ERP_STEP_NAMESERVER_OPEN;
2450 retval = ZFCP_ERP_CONTINUES;
2451 } else
2452 retval = ZFCP_ERP_FAILED;
2453 break;
2454 }
2455 /* else nameserver port is already open, fall through */
2456 case ZFCP_ERP_STEP_NAMESERVER_OPEN:
2457 if (!atomic_test_mask(ZFCP_STATUS_COMMON_OPEN,
2458 &adapter->nameserver_port->status)) {
2459 ZFCP_LOG_DEBUG("open failed for nameserver port\n");
2460 retval = ZFCP_ERP_FAILED;
2461 } else {
2462 ZFCP_LOG_DEBUG("nameserver port is open -> "
2463 "nameserver look-up for port 0x%016Lx\n",
2464 port->wwpn);
2465 retval = zfcp_erp_port_strategy_open_common_lookup
2466 (erp_action);
2467 }
2468 break;
2469
2470 case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
2471 if (!atomic_test_mask(ZFCP_STATUS_PORT_DID_DID, &port->status)) {
2472 if (atomic_test_mask
2473 (ZFCP_STATUS_PORT_INVALID_WWPN, &port->status)) {
2474 ZFCP_LOG_DEBUG("nameserver look-up failed "
2475 "for port 0x%016Lx "
2476 "(misconfigured WWPN?)\n",
2477 port->wwpn);
2478 zfcp_erp_port_failed(port);
2479 retval = ZFCP_ERP_EXIT;
2480 } else {
2481 ZFCP_LOG_DEBUG("nameserver look-up failed for "
2482 "port 0x%016Lx\n", port->wwpn);
2483 retval = ZFCP_ERP_FAILED;
2484 }
2485 } else {
2486 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> "
2487 "trying open\n", port->wwpn, port->d_id);
2488 retval = zfcp_erp_port_strategy_open_port(erp_action);
2489 }
2490 break;
2491
2492 case ZFCP_ERP_STEP_PORT_OPENING:
2493 /* D_ID might have changed during open */
2494 if (atomic_test_mask((ZFCP_STATUS_COMMON_OPEN |
2495 ZFCP_STATUS_PORT_DID_DID),
2496 &port->status)) {
2497 ZFCP_LOG_DEBUG("port 0x%016Lx is open\n", port->wwpn);
2498 retval = ZFCP_ERP_SUCCEEDED;
2499 } else {
2500 ZFCP_LOG_DEBUG("open failed for port 0x%016Lx\n",
2501 port->wwpn);
2502 retval = ZFCP_ERP_FAILED;
2503 }
2504 break;
2505
2506 default:
2507 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2508 erp_action->step);
2509 retval = ZFCP_ERP_FAILED;
2510 }
2511
2512 return retval;
2513 }
2514
2515 static int
2516 zfcp_erp_port_strategy_open_nameserver(struct zfcp_erp_action *erp_action)
2517 {
2518 int retval;
2519 struct zfcp_port *port = erp_action->port;
2520
2521 switch (erp_action->step) {
2522
2523 case ZFCP_ERP_STEP_UNINITIALIZED:
2524 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
2525 case ZFCP_ERP_STEP_PORT_CLOSING:
2526 ZFCP_LOG_DEBUG("port 0x%016Lx has d_id=0x%08x -> trying open\n",
2527 port->wwpn, port->d_id);
2528 retval = zfcp_erp_port_strategy_open_port(erp_action);
2529 break;
2530
2531 case ZFCP_ERP_STEP_PORT_OPENING:
2532 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &port->status)) {
2533 ZFCP_LOG_DEBUG("WKA port is open\n");
2534 retval = ZFCP_ERP_SUCCEEDED;
2535 } else {
2536 ZFCP_LOG_DEBUG("open failed for WKA port\n");
2537 retval = ZFCP_ERP_FAILED;
2538 }
2539 /* this is needed anyway (dont care for retval of wakeup) */
2540 ZFCP_LOG_DEBUG("continue other open port operations\n");
2541 zfcp_erp_port_strategy_open_nameserver_wakeup(erp_action);
2542 break;
2543
2544 default:
2545 ZFCP_LOG_NORMAL("bug: unknown erp step 0x%08x\n",
2546 erp_action->step);
2547 retval = ZFCP_ERP_FAILED;
2548 }
2549
2550 return retval;
2551 }
2552
2553 /*
2554 * function:
2555 *
2556 * purpose: makes the erp thread continue with reopen (physical) port
2557 * actions which have been paused until the name server port
2558 * is opened (or failed)
2559 *
2560 * returns: 0 (a kind of void retval, its not used)
2561 */
2562 static int
2563 zfcp_erp_port_strategy_open_nameserver_wakeup(struct zfcp_erp_action
2564 *ns_erp_action)
2565 {
2566 int retval = 0;
2567 unsigned long flags;
2568 struct zfcp_adapter *adapter = ns_erp_action->adapter;
2569 struct zfcp_erp_action *erp_action, *tmp;
2570
2571 read_lock_irqsave(&adapter->erp_lock, flags);
2572 list_for_each_entry_safe(erp_action, tmp, &adapter->erp_running_head,
2573 list) {
2574 debug_text_event(adapter->erp_dbf, 4, "p_pstnsw_n");
2575 debug_event(adapter->erp_dbf, 4, &erp_action->port->wwpn,
2576 sizeof (wwn_t));
2577 if (erp_action->step == ZFCP_ERP_STEP_NAMESERVER_OPEN) {
2578 debug_text_event(adapter->erp_dbf, 3, "p_pstnsw_w");
2579 debug_event(adapter->erp_dbf, 3,
2580 &erp_action->port->wwpn, sizeof (wwn_t));
2581 if (atomic_test_mask(
2582 ZFCP_STATUS_COMMON_ERP_FAILED,
2583 &adapter->nameserver_port->status))
2584 zfcp_erp_port_failed(erp_action->port);
2585 zfcp_erp_action_ready(erp_action);
2586 }
2587 }
2588 read_unlock_irqrestore(&adapter->erp_lock, flags);
2589
2590 return retval;
2591 }
2592
2593 /*
2594 * function:
2595 *
2596 * purpose:
2597 *
2598 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2599 * ZFCP_ERP_FAILED - action finished unsuccessfully
2600 */
2601 static int
2602 zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *erp_action)
2603 {
2604 int retval;
2605 struct zfcp_adapter *adapter = erp_action->adapter;
2606 struct zfcp_port *port = erp_action->port;
2607
2608 zfcp_erp_timeout_init(erp_action);
2609 retval = zfcp_fsf_close_physical_port(erp_action);
2610 if (retval == -ENOMEM) {
2611 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_nomem");
2612 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2613 retval = ZFCP_ERP_NOMEM;
2614 goto out;
2615 }
2616 erp_action->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
2617 if (retval != 0) {
2618 debug_text_event(adapter->erp_dbf, 5, "o_pfstc_cpf");
2619 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2620 /* could not send 'open', fail */
2621 retval = ZFCP_ERP_FAILED;
2622 goto out;
2623 }
2624 debug_text_event(adapter->erp_dbf, 6, "o_pfstc_cpok");
2625 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2626 retval = ZFCP_ERP_CONTINUES;
2627 out:
2628 return retval;
2629 }
2630
2631 static int
2632 zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
2633 {
2634 int retval = 0;
2635 struct zfcp_adapter *adapter = port->adapter;
2636
2637 debug_text_event(adapter->erp_dbf, 5, "p_pstclst");
2638 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2639
2640 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2641 ZFCP_STATUS_COMMON_CLOSING |
2642 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2643 ZFCP_STATUS_PORT_DID_DID |
2644 ZFCP_STATUS_PORT_PHYS_CLOSING |
2645 ZFCP_STATUS_PORT_INVALID_WWPN,
2646 &port->status);
2647 return retval;
2648 }
2649
2650 /*
2651 * function:
2652 *
2653 * purpose:
2654 *
2655 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2656 * ZFCP_ERP_FAILED - action finished unsuccessfully
2657 */
2658 static int
2659 zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
2660 {
2661 int retval;
2662 struct zfcp_adapter *adapter = erp_action->adapter;
2663 struct zfcp_port *port = erp_action->port;
2664
2665 zfcp_erp_timeout_init(erp_action);
2666 retval = zfcp_fsf_close_port(erp_action);
2667 if (retval == -ENOMEM) {
2668 debug_text_event(adapter->erp_dbf, 5, "p_pstc_nomem");
2669 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2670 retval = ZFCP_ERP_NOMEM;
2671 goto out;
2672 }
2673 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
2674 if (retval != 0) {
2675 debug_text_event(adapter->erp_dbf, 5, "p_pstc_cpf");
2676 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2677 /* could not send 'close', fail */
2678 retval = ZFCP_ERP_FAILED;
2679 goto out;
2680 }
2681 debug_text_event(adapter->erp_dbf, 6, "p_pstc_cpok");
2682 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2683 retval = ZFCP_ERP_CONTINUES;
2684 out:
2685 return retval;
2686 }
2687
2688 /*
2689 * function:
2690 *
2691 * purpose:
2692 *
2693 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2694 * ZFCP_ERP_FAILED - action finished unsuccessfully
2695 */
2696 static int
2697 zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
2698 {
2699 int retval;
2700 struct zfcp_adapter *adapter = erp_action->adapter;
2701 struct zfcp_port *port = erp_action->port;
2702
2703 zfcp_erp_timeout_init(erp_action);
2704 retval = zfcp_fsf_open_port(erp_action);
2705 if (retval == -ENOMEM) {
2706 debug_text_event(adapter->erp_dbf, 5, "p_psto_nomem");
2707 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2708 retval = ZFCP_ERP_NOMEM;
2709 goto out;
2710 }
2711 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
2712 if (retval != 0) {
2713 debug_text_event(adapter->erp_dbf, 5, "p_psto_opf");
2714 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2715 /* could not send 'open', fail */
2716 retval = ZFCP_ERP_FAILED;
2717 goto out;
2718 }
2719 debug_text_event(adapter->erp_dbf, 6, "p_psto_opok");
2720 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2721 retval = ZFCP_ERP_CONTINUES;
2722 out:
2723 return retval;
2724 }
2725
2726 /*
2727 * function:
2728 *
2729 * purpose:
2730 *
2731 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2732 * ZFCP_ERP_FAILED - action finished unsuccessfully
2733 */
2734 static int
2735 zfcp_erp_port_strategy_open_common_lookup(struct zfcp_erp_action *erp_action)
2736 {
2737 int retval;
2738 struct zfcp_adapter *adapter = erp_action->adapter;
2739 struct zfcp_port *port = erp_action->port;
2740
2741 zfcp_erp_timeout_init(erp_action);
2742 retval = zfcp_ns_gid_pn_request(erp_action);
2743 if (retval == -ENOMEM) {
2744 debug_text_event(adapter->erp_dbf, 5, "p_pstn_nomem");
2745 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2746 retval = ZFCP_ERP_NOMEM;
2747 goto out;
2748 }
2749 erp_action->step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
2750 if (retval != 0) {
2751 debug_text_event(adapter->erp_dbf, 5, "p_pstn_ref");
2752 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
2753 /* could not send nameserver request, fail */
2754 retval = ZFCP_ERP_FAILED;
2755 goto out;
2756 }
2757 debug_text_event(adapter->erp_dbf, 6, "p_pstn_reok");
2758 debug_event(adapter->erp_dbf, 6, &port->wwpn, sizeof (wwn_t));
2759 retval = ZFCP_ERP_CONTINUES;
2760 out:
2761 return retval;
2762 }
2763
2764 /*
2765 * function:
2766 *
2767 * purpose: this routine executes the 'Reopen Unit' action
2768 * currently no retries
2769 *
2770 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2771 * ZFCP_ERP_SUCCEEDED - action finished successfully
2772 * ZFCP_ERP_FAILED - action finished unsuccessfully
2773 */
2774 static int
2775 zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
2776 {
2777 int retval = ZFCP_ERP_FAILED;
2778 struct zfcp_unit *unit = erp_action->unit;
2779 struct zfcp_adapter *adapter = erp_action->adapter;
2780
2781 switch (erp_action->step) {
2782
2783 /*
2784 * FIXME:
2785 * the ULP spec. begs for waiting for oustanding commands
2786 */
2787 case ZFCP_ERP_STEP_UNINITIALIZED:
2788 zfcp_erp_unit_strategy_clearstati(unit);
2789 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2790 ZFCP_LOG_DEBUG("unit 0x%016Lx is open -> "
2791 "trying close\n", unit->fcp_lun);
2792 retval = zfcp_erp_unit_strategy_close(erp_action);
2793 break;
2794 }
2795 /* else it's already closed, fall through */
2796 case ZFCP_ERP_STEP_UNIT_CLOSING:
2797 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2798 ZFCP_LOG_DEBUG("close failed for unit 0x%016Lx\n",
2799 unit->fcp_lun);
2800 retval = ZFCP_ERP_FAILED;
2801 } else {
2802 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
2803 retval = ZFCP_ERP_EXIT;
2804 else {
2805 ZFCP_LOG_DEBUG("unit 0x%016Lx is not open -> "
2806 "trying open\n", unit->fcp_lun);
2807 retval =
2808 zfcp_erp_unit_strategy_open(erp_action);
2809 }
2810 }
2811 break;
2812
2813 case ZFCP_ERP_STEP_UNIT_OPENING:
2814 if (atomic_test_mask(ZFCP_STATUS_COMMON_OPEN, &unit->status)) {
2815 ZFCP_LOG_DEBUG("unit 0x%016Lx is open\n",
2816 unit->fcp_lun);
2817 retval = ZFCP_ERP_SUCCEEDED;
2818 } else {
2819 ZFCP_LOG_DEBUG("open failed for unit 0x%016Lx\n",
2820 unit->fcp_lun);
2821 retval = ZFCP_ERP_FAILED;
2822 }
2823 break;
2824 }
2825
2826 debug_text_event(adapter->erp_dbf, 3, "u_ust/ret");
2827 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof (fcp_lun_t));
2828 debug_event(adapter->erp_dbf, 3, &erp_action->action, sizeof (int));
2829 debug_event(adapter->erp_dbf, 3, &retval, sizeof (int));
2830 return retval;
2831 }
2832
2833 static int
2834 zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
2835 {
2836 int retval = 0;
2837 struct zfcp_adapter *adapter = unit->port->adapter;
2838
2839 debug_text_event(adapter->erp_dbf, 5, "u_ustclst");
2840 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
2841
2842 atomic_clear_mask(ZFCP_STATUS_COMMON_OPENING |
2843 ZFCP_STATUS_COMMON_CLOSING |
2844 ZFCP_STATUS_COMMON_ACCESS_DENIED |
2845 ZFCP_STATUS_UNIT_SHARED |
2846 ZFCP_STATUS_UNIT_READONLY,
2847 &unit->status);
2848
2849 return retval;
2850 }
2851
2852 /*
2853 * function:
2854 *
2855 * purpose:
2856 *
2857 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2858 * ZFCP_ERP_FAILED - action finished unsuccessfully
2859 */
2860 static int
2861 zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
2862 {
2863 int retval;
2864 struct zfcp_adapter *adapter = erp_action->adapter;
2865 struct zfcp_unit *unit = erp_action->unit;
2866
2867 zfcp_erp_timeout_init(erp_action);
2868 retval = zfcp_fsf_close_unit(erp_action);
2869 if (retval == -ENOMEM) {
2870 debug_text_event(adapter->erp_dbf, 5, "u_ustc_nomem");
2871 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2872 sizeof (fcp_lun_t));
2873 retval = ZFCP_ERP_NOMEM;
2874 goto out;
2875 }
2876 erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
2877 if (retval != 0) {
2878 debug_text_event(adapter->erp_dbf, 5, "u_ustc_cuf");
2879 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2880 sizeof (fcp_lun_t));
2881 /* could not send 'close', fail */
2882 retval = ZFCP_ERP_FAILED;
2883 goto out;
2884 }
2885 debug_text_event(adapter->erp_dbf, 6, "u_ustc_cuok");
2886 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2887 retval = ZFCP_ERP_CONTINUES;
2888
2889 out:
2890 return retval;
2891 }
2892
2893 /*
2894 * function:
2895 *
2896 * purpose:
2897 *
2898 * returns: ZFCP_ERP_CONTINUES - action continues (asynchronously)
2899 * ZFCP_ERP_FAILED - action finished unsuccessfully
2900 */
2901 static int
2902 zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
2903 {
2904 int retval;
2905 struct zfcp_adapter *adapter = erp_action->adapter;
2906 struct zfcp_unit *unit = erp_action->unit;
2907
2908 zfcp_erp_timeout_init(erp_action);
2909 retval = zfcp_fsf_open_unit(erp_action);
2910 if (retval == -ENOMEM) {
2911 debug_text_event(adapter->erp_dbf, 5, "u_usto_nomem");
2912 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2913 sizeof (fcp_lun_t));
2914 retval = ZFCP_ERP_NOMEM;
2915 goto out;
2916 }
2917 erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
2918 if (retval != 0) {
2919 debug_text_event(adapter->erp_dbf, 5, "u_usto_ouf");
2920 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun,
2921 sizeof (fcp_lun_t));
2922 /* could not send 'open', fail */
2923 retval = ZFCP_ERP_FAILED;
2924 goto out;
2925 }
2926 debug_text_event(adapter->erp_dbf, 6, "u_usto_ouok");
2927 debug_event(adapter->erp_dbf, 6, &unit->fcp_lun, sizeof (fcp_lun_t));
2928 retval = ZFCP_ERP_CONTINUES;
2929 out:
2930 return retval;
2931 }
2932
2933 static inline void
2934 zfcp_erp_timeout_init(struct zfcp_erp_action *erp_action)
2935 {
2936 init_timer(&erp_action->timer);
2937 erp_action->timer.function = zfcp_erp_timeout_handler;
2938 erp_action->timer.data = (unsigned long) erp_action;
2939 /* jiffies will be added in zfcp_fsf_req_send */
2940 erp_action->timer.expires = ZFCP_ERP_FSFREQ_TIMEOUT;
2941 }
2942
2943 /*
2944 * function:
2945 *
2946 * purpose: enqueue the specified error recovery action, if needed
2947 *
2948 * returns:
2949 */
2950 static int
2951 zfcp_erp_action_enqueue(int action,
2952 struct zfcp_adapter *adapter,
2953 struct zfcp_port *port, struct zfcp_unit *unit)
2954 {
2955 int retval = 1;
2956 struct zfcp_erp_action *erp_action = NULL;
2957 int stronger_action = 0;
2958 u32 status = 0;
2959
2960 /*
2961 * We need some rules here which check whether we really need
2962 * this action or whether we should just drop it.
2963 * E.g. if there is a unfinished 'Reopen Port' request then we drop a
2964 * 'Reopen Unit' request for an associated unit since we can't
2965 * satisfy this request now. A 'Reopen Port' action will trigger
2966 * 'Reopen Unit' actions when it completes.
2967 * Thus, there are only actions in the queue which can immediately be
2968 * executed. This makes the processing of the action queue more
2969 * efficient.
2970 */
2971
2972 if (!atomic_test_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP,
2973 &adapter->status))
2974 return -EIO;
2975
2976 debug_event(adapter->erp_dbf, 4, &action, sizeof (int));
2977 /* check whether we really need this */
2978 switch (action) {
2979 case ZFCP_ERP_ACTION_REOPEN_UNIT:
2980 if (atomic_test_mask
2981 (ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status)) {
2982 debug_text_event(adapter->erp_dbf, 4, "u_actenq_drp");
2983 debug_event(adapter->erp_dbf, 4, &port->wwpn,
2984 sizeof (wwn_t));
2985 debug_event(adapter->erp_dbf, 4, &unit->fcp_lun,
2986 sizeof (fcp_lun_t));
2987 goto out;
2988 }
2989 if (!atomic_test_mask
2990 (ZFCP_STATUS_COMMON_RUNNING, &port->status) ||
2991 atomic_test_mask
2992 (ZFCP_STATUS_COMMON_ERP_FAILED, &port->status)) {
2993 goto out;
2994 }
2995 if (!atomic_test_mask
2996 (ZFCP_STATUS_COMMON_UNBLOCKED, &port->status)) {
2997 stronger_action = ZFCP_ERP_ACTION_REOPEN_PORT;
2998 unit = NULL;
2999 }
3000 /* fall through !!! */
3001
3002 case ZFCP_ERP_ACTION_REOPEN_PORT:
3003 if (atomic_test_mask
3004 (ZFCP_STATUS_COMMON_ERP_INUSE, &port->status)) {
3005 debug_text_event(adapter->erp_dbf, 4, "p_actenq_drp");
3006 debug_event(adapter->erp_dbf, 4, &port->wwpn,
3007 sizeof (wwn_t));
3008 goto out;
3009 }
3010 /* fall through !!! */
3011
3012 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3013 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3014 &port->status)) {
3015 if (port->erp_action.action !=
3016 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED) {
3017 ZFCP_LOG_INFO("dropped erp action %i (port "
3018 "0x%016Lx, action in use: %i)\n",
3019 action, port->wwpn,
3020 port->erp_action.action);
3021 debug_text_event(adapter->erp_dbf, 4,
3022 "pf_actenq_drp");
3023 } else
3024 debug_text_event(adapter->erp_dbf, 4,
3025 "pf_actenq_drpcp");
3026 debug_event(adapter->erp_dbf, 4, &port->wwpn,
3027 sizeof (wwn_t));
3028 goto out;
3029 }
3030 if (!atomic_test_mask
3031 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status) ||
3032 atomic_test_mask
3033 (ZFCP_STATUS_COMMON_ERP_FAILED, &adapter->status)) {
3034 goto out;
3035 }
3036 if (!atomic_test_mask
3037 (ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status)) {
3038 stronger_action = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
3039 port = NULL;
3040 }
3041 /* fall through !!! */
3042
3043 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3044 if (atomic_test_mask
3045 (ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status)) {
3046 debug_text_event(adapter->erp_dbf, 4, "a_actenq_drp");
3047 goto out;
3048 }
3049 break;
3050
3051 default:
3052 debug_text_exception(adapter->erp_dbf, 1, "a_actenq_bug");
3053 debug_event(adapter->erp_dbf, 1, &action, sizeof (int));
3054 ZFCP_LOG_NORMAL("bug: unknown erp action requested "
3055 "on adapter %s (action=%d)\n",
3056 zfcp_get_busid_by_adapter(adapter), action);
3057 goto out;
3058 }
3059
3060 /* check whether we need something stronger first */
3061 if (stronger_action) {
3062 debug_text_event(adapter->erp_dbf, 4, "a_actenq_str");
3063 debug_event(adapter->erp_dbf, 4, &stronger_action,
3064 sizeof (int));
3065 ZFCP_LOG_DEBUG("stronger erp action %d needed before "
3066 "erp action %d on adapter %s\n",
3067 stronger_action, action,
3068 zfcp_get_busid_by_adapter(adapter));
3069 action = stronger_action;
3070 }
3071
3072 /* mark adapter to have some error recovery pending */
3073 atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
3074
3075 /* setup error recovery action */
3076 switch (action) {
3077
3078 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3079 zfcp_unit_get(unit);
3080 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
3081 erp_action = &unit->erp_action;
3082 if (!atomic_test_mask
3083 (ZFCP_STATUS_COMMON_RUNNING, &unit->status))
3084 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3085 break;
3086
3087 case ZFCP_ERP_ACTION_REOPEN_PORT:
3088 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3089 zfcp_port_get(port);
3090 zfcp_erp_action_dismiss_port(port);
3091 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
3092 erp_action = &port->erp_action;
3093 if (!atomic_test_mask
3094 (ZFCP_STATUS_COMMON_RUNNING, &port->status))
3095 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3096 break;
3097
3098 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3099 zfcp_adapter_get(adapter);
3100 zfcp_erp_action_dismiss_adapter(adapter);
3101 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
3102 erp_action = &adapter->erp_action;
3103 if (!atomic_test_mask
3104 (ZFCP_STATUS_COMMON_RUNNING, &adapter->status))
3105 status = ZFCP_STATUS_ERP_CLOSE_ONLY;
3106 break;
3107 }
3108
3109 debug_text_event(adapter->erp_dbf, 4, "a_actenq");
3110
3111 memset(erp_action, 0, sizeof (struct zfcp_erp_action));
3112 erp_action->adapter = adapter;
3113 erp_action->port = port;
3114 erp_action->unit = unit;
3115 erp_action->action = action;
3116 erp_action->status = status;
3117
3118 ++adapter->erp_total_count;
3119
3120 /* finally put it into 'ready' queue and kick erp thread */
3121 list_add(&erp_action->list, &adapter->erp_ready_head);
3122 up(&adapter->erp_ready_sem);
3123 retval = 0;
3124 out:
3125 return retval;
3126 }
3127
3128 static int
3129 zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
3130 {
3131 int retval = 0;
3132 struct zfcp_adapter *adapter = erp_action->adapter;
3133
3134 --adapter->erp_total_count;
3135 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
3136 --adapter->erp_low_mem_count;
3137 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
3138 }
3139
3140 debug_text_event(adapter->erp_dbf, 4, "a_actdeq");
3141 debug_event(adapter->erp_dbf, 4, &erp_action->action, sizeof (int));
3142 list_del(&erp_action->list);
3143 switch (erp_action->action) {
3144 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3145 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3146 &erp_action->unit->status);
3147 break;
3148 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3149 case ZFCP_ERP_ACTION_REOPEN_PORT:
3150 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3151 &erp_action->port->status);
3152 break;
3153 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3154 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
3155 &erp_action->adapter->status);
3156 break;
3157 default:
3158 /* bug */
3159 break;
3160 }
3161 return retval;
3162 }
3163
3164 /**
3165 * zfcp_erp_action_cleanup
3166 *
3167 * Register unit with scsi stack if appropriate and fix reference counts.
3168 * Note: Temporary units are not registered with scsi stack.
3169 */
3170 static void
3171 zfcp_erp_action_cleanup(int action, struct zfcp_adapter *adapter,
3172 struct zfcp_port *port, struct zfcp_unit *unit,
3173 int result)
3174 {
3175 switch (action) {
3176 case ZFCP_ERP_ACTION_REOPEN_UNIT:
3177 if ((result == ZFCP_ERP_SUCCEEDED)
3178 && (!atomic_test_mask(ZFCP_STATUS_UNIT_TEMPORARY,
3179 &unit->status))
3180 && !unit->device
3181 && port->rport) {
3182 atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
3183 &unit->status);
3184 scsi_scan_target(&port->rport->dev, 0,
3185 port->rport->scsi_target_id,
3186 unit->scsi_lun, 0);
3187 }
3188 zfcp_unit_put(unit);
3189 break;
3190 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
3191 case ZFCP_ERP_ACTION_REOPEN_PORT:
3192 if (atomic_test_mask(ZFCP_STATUS_PORT_NO_WWPN,
3193 &port->status)) {
3194 zfcp_port_put(port);
3195 break;
3196 }
3197
3198 if ((result == ZFCP_ERP_SUCCEEDED)
3199 && !port->rport) {
3200 struct fc_rport_identifiers ids;
3201 ids.node_name = port->wwnn;
3202 ids.port_name = port->wwpn;
3203 ids.port_id = port->d_id;
3204 ids.roles = FC_RPORT_ROLE_FCP_TARGET;
3205 port->rport =
3206 fc_remote_port_add(adapter->scsi_host, 0, &ids);
3207 if (!port->rport)
3208 ZFCP_LOG_NORMAL("failed registration of rport"
3209 "(adapter %s, wwpn=0x%016Lx)\n",
3210 zfcp_get_busid_by_port(port),
3211 port->wwpn);
3212 else {
3213 scsi_flush_work(adapter->scsi_host);
3214 port->rport->maxframe_size = port->maxframe_size;
3215 port->rport->supported_classes =
3216 port->supported_classes;
3217 }
3218 }
3219 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
3220 fc_remote_port_delete(port->rport);
3221 port->rport = NULL;
3222 }
3223 zfcp_port_put(port);
3224 break;
3225 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
3226 if (result != ZFCP_ERP_SUCCEEDED) {
3227 struct zfcp_port *port;
3228 list_for_each_entry(port, &adapter->port_list_head, list)
3229 if (port->rport &&
3230 !atomic_test_mask(ZFCP_STATUS_PORT_WKA,
3231 &port->status)) {
3232 fc_remote_port_delete(port->rport);
3233 port->rport = NULL;
3234 }
3235 }
3236 zfcp_adapter_put(adapter);
3237 break;
3238 default:
3239 break;
3240 }
3241 }
3242
3243
3244 void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
3245 {
3246 struct zfcp_port *port;
3247
3248 debug_text_event(adapter->erp_dbf, 5, "a_actab");
3249 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status))
3250 zfcp_erp_action_dismiss(&adapter->erp_action);
3251 else
3252 list_for_each_entry(port, &adapter->port_list_head, list)
3253 zfcp_erp_action_dismiss_port(port);
3254 }
3255
3256 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
3257 {
3258 struct zfcp_unit *unit;
3259 struct zfcp_adapter *adapter = port->adapter;
3260
3261 debug_text_event(adapter->erp_dbf, 5, "p_actab");
3262 debug_event(adapter->erp_dbf, 5, &port->wwpn, sizeof (wwn_t));
3263 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status))
3264 zfcp_erp_action_dismiss(&port->erp_action);
3265 else
3266 list_for_each_entry(unit, &port->unit_list_head, list)
3267 zfcp_erp_action_dismiss_unit(unit);
3268 }
3269
3270 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
3271 {
3272 struct zfcp_adapter *adapter = unit->port->adapter;
3273
3274 debug_text_event(adapter->erp_dbf, 5, "u_actab");
3275 debug_event(adapter->erp_dbf, 5, &unit->fcp_lun, sizeof (fcp_lun_t));
3276 if (atomic_test_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status))
3277 zfcp_erp_action_dismiss(&unit->erp_action);
3278 }
3279
3280 static inline void
3281 zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
3282 {
3283 struct zfcp_adapter *adapter = erp_action->adapter;
3284
3285 debug_text_event(adapter->erp_dbf, 6, "a_toru");
3286 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3287 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
3288 }
3289
3290 static inline void
3291 zfcp_erp_action_to_ready(struct zfcp_erp_action *erp_action)
3292 {
3293 struct zfcp_adapter *adapter = erp_action->adapter;
3294
3295 debug_text_event(adapter->erp_dbf, 6, "a_tore");
3296 debug_event(adapter->erp_dbf, 6, &erp_action->action, sizeof (int));
3297 list_move(&erp_action->list, &erp_action->adapter->erp_ready_head);
3298 }
3299
3300 void
3301 zfcp_erp_port_boxed(struct zfcp_port *port)
3302 {
3303 struct zfcp_adapter *adapter = port->adapter;
3304 unsigned long flags;
3305
3306 debug_text_event(adapter->erp_dbf, 3, "p_access_boxed");
3307 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3308 read_lock_irqsave(&zfcp_data.config_lock, flags);
3309 zfcp_erp_modify_port_status(port,
3310 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3311 ZFCP_SET);
3312 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3313 zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED);
3314 }
3315
3316 void
3317 zfcp_erp_unit_boxed(struct zfcp_unit *unit)
3318 {
3319 struct zfcp_adapter *adapter = unit->port->adapter;
3320
3321 debug_text_event(adapter->erp_dbf, 3, "u_access_boxed");
3322 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3323 zfcp_erp_modify_unit_status(unit,
3324 ZFCP_STATUS_COMMON_ACCESS_BOXED,
3325 ZFCP_SET);
3326 zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED);
3327 }
3328
3329 void
3330 zfcp_erp_port_access_denied(struct zfcp_port *port)
3331 {
3332 struct zfcp_adapter *adapter = port->adapter;
3333 unsigned long flags;
3334
3335 debug_text_event(adapter->erp_dbf, 3, "p_access_denied");
3336 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3337 read_lock_irqsave(&zfcp_data.config_lock, flags);
3338 zfcp_erp_modify_port_status(port,
3339 ZFCP_STATUS_COMMON_ERP_FAILED |
3340 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3341 ZFCP_SET);
3342 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3343 }
3344
3345 void
3346 zfcp_erp_unit_access_denied(struct zfcp_unit *unit)
3347 {
3348 struct zfcp_adapter *adapter = unit->port->adapter;
3349
3350 debug_text_event(adapter->erp_dbf, 3, "u_access_denied");
3351 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3352 zfcp_erp_modify_unit_status(unit,
3353 ZFCP_STATUS_COMMON_ERP_FAILED |
3354 ZFCP_STATUS_COMMON_ACCESS_DENIED,
3355 ZFCP_SET);
3356 }
3357
3358 void
3359 zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter)
3360 {
3361 struct zfcp_port *port;
3362 unsigned long flags;
3363
3364 if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
3365 return;
3366
3367 debug_text_event(adapter->erp_dbf, 3, "a_access_recover");
3368 debug_event(adapter->erp_dbf, 3, zfcp_get_busid_by_adapter(adapter), 8);
3369
3370 read_lock_irqsave(&zfcp_data.config_lock, flags);
3371 if (adapter->nameserver_port)
3372 zfcp_erp_port_access_changed(adapter->nameserver_port);
3373 list_for_each_entry(port, &adapter->port_list_head, list)
3374 if (port != adapter->nameserver_port)
3375 zfcp_erp_port_access_changed(port);
3376 read_unlock_irqrestore(&zfcp_data.config_lock, flags);
3377 }
3378
3379 void
3380 zfcp_erp_port_access_changed(struct zfcp_port *port)
3381 {
3382 struct zfcp_adapter *adapter = port->adapter;
3383 struct zfcp_unit *unit;
3384
3385 debug_text_event(adapter->erp_dbf, 3, "p_access_recover");
3386 debug_event(adapter->erp_dbf, 3, &port->wwpn, sizeof(wwn_t));
3387
3388 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3389 &port->status) &&
3390 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3391 &port->status)) {
3392 if (!atomic_test_mask(ZFCP_STATUS_PORT_WKA, &port->status))
3393 list_for_each_entry(unit, &port->unit_list_head, list)
3394 zfcp_erp_unit_access_changed(unit);
3395 return;
3396 }
3397
3398 ZFCP_LOG_NORMAL("reopen of port 0x%016Lx on adapter %s "
3399 "(due to ACT update)\n",
3400 port->wwpn, zfcp_get_busid_by_adapter(adapter));
3401 if (zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3402 ZFCP_LOG_NORMAL("failed reopen of port"
3403 "(adapter %s, wwpn=0x%016Lx)\n",
3404 zfcp_get_busid_by_adapter(adapter), port->wwpn);
3405 }
3406
3407 void
3408 zfcp_erp_unit_access_changed(struct zfcp_unit *unit)
3409 {
3410 struct zfcp_adapter *adapter = unit->port->adapter;
3411
3412 debug_text_event(adapter->erp_dbf, 3, "u_access_recover");
3413 debug_event(adapter->erp_dbf, 3, &unit->fcp_lun, sizeof(fcp_lun_t));
3414
3415 if (!atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED,
3416 &unit->status) &&
3417 !atomic_test_mask(ZFCP_STATUS_COMMON_ACCESS_BOXED,
3418 &unit->status))
3419 return;
3420
3421 ZFCP_LOG_NORMAL("reopen of unit 0x%016Lx on port 0x%016Lx "
3422 " on adapter %s (due to ACT update)\n",
3423 unit->fcp_lun, unit->port->wwpn,
3424 zfcp_get_busid_by_adapter(adapter));
3425 if (zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
3426 ZFCP_LOG_NORMAL("failed reopen of unit (adapter %s, "
3427 "wwpn=0x%016Lx, fcp_lun=0x%016Lx)\n",
3428 zfcp_get_busid_by_adapter(adapter),
3429 unit->port->wwpn, unit->fcp_lun);
3430 }
3431
3432 #undef ZFCP_LOG_AREA
Support for the Chinese Samsung S3C2440 based development boards