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