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