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