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