Merge branches 'tracing/ftrace' and 'tracing/urgent' into tracing/core
[linux-2.6] / drivers / s390 / scsi / zfcp_erp.c
1 /*
2  * zfcp device driver
3  *
4  * Error Recovery Procedures (ERP).
5  *
6  * Copyright IBM Corporation 2002, 2008
7  */
8
9 #include "zfcp_ext.h"
10
11 #define ZFCP_MAX_ERPS                   3
12
13 enum zfcp_erp_act_flags {
14         ZFCP_STATUS_ERP_TIMEDOUT        = 0x10000000,
15         ZFCP_STATUS_ERP_CLOSE_ONLY      = 0x01000000,
16         ZFCP_STATUS_ERP_DISMISSING      = 0x00100000,
17         ZFCP_STATUS_ERP_DISMISSED       = 0x00200000,
18         ZFCP_STATUS_ERP_LOWMEM          = 0x00400000,
19 };
20
21 enum zfcp_erp_steps {
22         ZFCP_ERP_STEP_UNINITIALIZED     = 0x0000,
23         ZFCP_ERP_STEP_FSF_XCONFIG       = 0x0001,
24         ZFCP_ERP_STEP_PHYS_PORT_CLOSING = 0x0010,
25         ZFCP_ERP_STEP_PORT_CLOSING      = 0x0100,
26         ZFCP_ERP_STEP_NAMESERVER_LOOKUP = 0x0400,
27         ZFCP_ERP_STEP_PORT_OPENING      = 0x0800,
28         ZFCP_ERP_STEP_UNIT_CLOSING      = 0x1000,
29         ZFCP_ERP_STEP_UNIT_OPENING      = 0x2000,
30 };
31
32 enum zfcp_erp_act_type {
33         ZFCP_ERP_ACTION_REOPEN_UNIT        = 1,
34         ZFCP_ERP_ACTION_REOPEN_PORT        = 2,
35         ZFCP_ERP_ACTION_REOPEN_PORT_FORCED = 3,
36         ZFCP_ERP_ACTION_REOPEN_ADAPTER     = 4,
37 };
38
39 enum zfcp_erp_act_state {
40         ZFCP_ERP_ACTION_RUNNING = 1,
41         ZFCP_ERP_ACTION_READY   = 2,
42 };
43
44 enum zfcp_erp_act_result {
45         ZFCP_ERP_SUCCEEDED = 0,
46         ZFCP_ERP_FAILED    = 1,
47         ZFCP_ERP_CONTINUES = 2,
48         ZFCP_ERP_EXIT      = 3,
49         ZFCP_ERP_DISMISSED = 4,
50         ZFCP_ERP_NOMEM     = 5,
51 };
52
53 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
54 {
55         zfcp_erp_modify_adapter_status(adapter, 15, NULL,
56                                        ZFCP_STATUS_COMMON_UNBLOCKED | mask,
57                                        ZFCP_CLEAR);
58 }
59
60 static int zfcp_erp_action_exists(struct zfcp_erp_action *act)
61 {
62         struct zfcp_erp_action *curr_act;
63
64         list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
65                 if (act == curr_act)
66                         return ZFCP_ERP_ACTION_RUNNING;
67         return 0;
68 }
69
70 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
71 {
72         struct zfcp_adapter *adapter = act->adapter;
73
74         list_move(&act->list, &act->adapter->erp_ready_head);
75         zfcp_rec_dbf_event_action(146, act);
76         up(&adapter->erp_ready_sem);
77         zfcp_rec_dbf_event_thread(2, adapter);
78 }
79
80 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
81 {
82         act->status |= ZFCP_STATUS_ERP_DISMISSED;
83         if (zfcp_erp_action_exists(act) == ZFCP_ERP_ACTION_RUNNING)
84                 zfcp_erp_action_ready(act);
85 }
86
87 static void zfcp_erp_action_dismiss_unit(struct zfcp_unit *unit)
88 {
89         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
90                 zfcp_erp_action_dismiss(&unit->erp_action);
91 }
92
93 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
94 {
95         struct zfcp_unit *unit;
96
97         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
98                 zfcp_erp_action_dismiss(&port->erp_action);
99         else
100                 list_for_each_entry(unit, &port->unit_list_head, list)
101                     zfcp_erp_action_dismiss_unit(unit);
102 }
103
104 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
105 {
106         struct zfcp_port *port;
107
108         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
109                 zfcp_erp_action_dismiss(&adapter->erp_action);
110         else
111                 list_for_each_entry(port, &adapter->port_list_head, list)
112                     zfcp_erp_action_dismiss_port(port);
113 }
114
115 static int zfcp_erp_required_act(int want, struct zfcp_adapter *adapter,
116                                  struct zfcp_port *port,
117                                  struct zfcp_unit *unit)
118 {
119         int need = want;
120         int u_status, p_status, a_status;
121
122         switch (want) {
123         case ZFCP_ERP_ACTION_REOPEN_UNIT:
124                 u_status = atomic_read(&unit->status);
125                 if (u_status & ZFCP_STATUS_COMMON_ERP_INUSE)
126                         return 0;
127                 p_status = atomic_read(&port->status);
128                 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
129                       p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
130                         return 0;
131                 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
132                         need = ZFCP_ERP_ACTION_REOPEN_PORT;
133                 /* fall through */
134         case ZFCP_ERP_ACTION_REOPEN_PORT:
135         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
136                 p_status = atomic_read(&port->status);
137                 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
138                         return 0;
139                 a_status = atomic_read(&adapter->status);
140                 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
141                       a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
142                         return 0;
143                 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
144                         need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
145                 /* fall through */
146         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
147                 a_status = atomic_read(&adapter->status);
148                 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
149                         return 0;
150         }
151
152         return need;
153 }
154
155 static struct zfcp_erp_action *zfcp_erp_setup_act(int need,
156                                                   struct zfcp_adapter *adapter,
157                                                   struct zfcp_port *port,
158                                                   struct zfcp_unit *unit)
159 {
160         struct zfcp_erp_action *erp_action;
161         u32 status = 0;
162
163         switch (need) {
164         case ZFCP_ERP_ACTION_REOPEN_UNIT:
165                 zfcp_unit_get(unit);
166                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &unit->status);
167                 erp_action = &unit->erp_action;
168                 if (!(atomic_read(&unit->status) & ZFCP_STATUS_COMMON_RUNNING))
169                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
170                 break;
171
172         case ZFCP_ERP_ACTION_REOPEN_PORT:
173         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
174                 zfcp_port_get(port);
175                 zfcp_erp_action_dismiss_port(port);
176                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
177                 erp_action = &port->erp_action;
178                 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
179                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
180                 break;
181
182         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
183                 zfcp_adapter_get(adapter);
184                 zfcp_erp_action_dismiss_adapter(adapter);
185                 atomic_set_mask(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
186                 erp_action = &adapter->erp_action;
187                 if (!(atomic_read(&adapter->status) &
188                       ZFCP_STATUS_COMMON_RUNNING))
189                         status = ZFCP_STATUS_ERP_CLOSE_ONLY;
190                 break;
191
192         default:
193                 return NULL;
194         }
195
196         memset(erp_action, 0, sizeof(struct zfcp_erp_action));
197         erp_action->adapter = adapter;
198         erp_action->port = port;
199         erp_action->unit = unit;
200         erp_action->action = need;
201         erp_action->status = status;
202
203         return erp_action;
204 }
205
206 static int zfcp_erp_action_enqueue(int want, struct zfcp_adapter *adapter,
207                                    struct zfcp_port *port,
208                                    struct zfcp_unit *unit, u8 id, void *ref)
209 {
210         int retval = 1, need;
211         struct zfcp_erp_action *act = NULL;
212
213         if (!(atomic_read(&adapter->status) &
214               ZFCP_STATUS_ADAPTER_ERP_THREAD_UP))
215                 return -EIO;
216
217         need = zfcp_erp_required_act(want, adapter, port, unit);
218         if (!need)
219                 goto out;
220
221         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
222         act = zfcp_erp_setup_act(need, adapter, port, unit);
223         if (!act)
224                 goto out;
225         ++adapter->erp_total_count;
226         list_add_tail(&act->list, &adapter->erp_ready_head);
227         up(&adapter->erp_ready_sem);
228         zfcp_rec_dbf_event_thread(1, adapter);
229         retval = 0;
230  out:
231         zfcp_rec_dbf_event_trigger(id, ref, want, need, act,
232                                    adapter, port, unit);
233         return retval;
234 }
235
236 static int _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
237                                     int clear_mask, u8 id, void *ref)
238 {
239         zfcp_erp_adapter_block(adapter, clear_mask);
240
241         /* ensure propagation of failed status to new devices */
242         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
243                 zfcp_erp_adapter_failed(adapter, 13, NULL);
244                 return -EIO;
245         }
246         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
247                                        adapter, NULL, NULL, id, ref);
248 }
249
250 /**
251  * zfcp_erp_adapter_reopen - Reopen adapter.
252  * @adapter: Adapter to reopen.
253  * @clear: Status flags to clear.
254  * @id: Id for debug trace event.
255  * @ref: Reference for debug trace event.
256  */
257 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
258                              u8 id, void *ref)
259 {
260         unsigned long flags;
261
262         read_lock_irqsave(&zfcp_data.config_lock, flags);
263         write_lock(&adapter->erp_lock);
264         _zfcp_erp_adapter_reopen(adapter, clear, id, ref);
265         write_unlock(&adapter->erp_lock);
266         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
267 }
268
269 /**
270  * zfcp_erp_adapter_shutdown - Shutdown adapter.
271  * @adapter: Adapter to shut down.
272  * @clear: Status flags to clear.
273  * @id: Id for debug trace event.
274  * @ref: Reference for debug trace event.
275  */
276 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
277                                u8 id, void *ref)
278 {
279         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
280         zfcp_erp_adapter_reopen(adapter, clear | flags, id, ref);
281 }
282
283 /**
284  * zfcp_erp_port_shutdown - Shutdown port
285  * @port: Port to shut down.
286  * @clear: Status flags to clear.
287  * @id: Id for debug trace event.
288  * @ref: Reference for debug trace event.
289  */
290 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, u8 id, void *ref)
291 {
292         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
293         zfcp_erp_port_reopen(port, clear | flags, id, ref);
294 }
295
296 /**
297  * zfcp_erp_unit_shutdown - Shutdown unit
298  * @unit: Unit to shut down.
299  * @clear: Status flags to clear.
300  * @id: Id for debug trace event.
301  * @ref: Reference for debug trace event.
302  */
303 void zfcp_erp_unit_shutdown(struct zfcp_unit *unit, int clear, u8 id, void *ref)
304 {
305         int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
306         zfcp_erp_unit_reopen(unit, clear | flags, id, ref);
307 }
308
309 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
310 {
311         zfcp_erp_modify_port_status(port, 17, NULL,
312                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear,
313                                     ZFCP_CLEAR);
314 }
315
316 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port,
317                                          int clear, u8 id, void *ref)
318 {
319         zfcp_erp_port_block(port, clear);
320
321         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
322                 return;
323
324         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
325                                 port->adapter, port, NULL, id, ref);
326 }
327
328 /**
329  * zfcp_erp_port_forced_reopen - Forced close of port and open again
330  * @port: Port to force close and to reopen.
331  * @id: Id for debug trace event.
332  * @ref: Reference for debug trace event.
333  */
334 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear, u8 id,
335                                  void *ref)
336 {
337         unsigned long flags;
338         struct zfcp_adapter *adapter = port->adapter;
339
340         read_lock_irqsave(&zfcp_data.config_lock, flags);
341         write_lock(&adapter->erp_lock);
342         _zfcp_erp_port_forced_reopen(port, clear, id, ref);
343         write_unlock(&adapter->erp_lock);
344         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
345 }
346
347 static int _zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id,
348                                  void *ref)
349 {
350         zfcp_erp_port_block(port, clear);
351
352         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
353                 /* ensure propagation of failed status to new devices */
354                 zfcp_erp_port_failed(port, 14, NULL);
355                 return -EIO;
356         }
357
358         return zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
359                                        port->adapter, port, NULL, id, ref);
360 }
361
362 /**
363  * zfcp_erp_port_reopen - trigger remote port recovery
364  * @port: port to recover
365  * @clear_mask: flags in port status to be cleared
366  *
367  * Returns 0 if recovery has been triggered, < 0 if not.
368  */
369 int zfcp_erp_port_reopen(struct zfcp_port *port, int clear, u8 id, void *ref)
370 {
371         unsigned long flags;
372         int retval;
373         struct zfcp_adapter *adapter = port->adapter;
374
375         read_lock_irqsave(&zfcp_data.config_lock, flags);
376         write_lock(&adapter->erp_lock);
377         retval = _zfcp_erp_port_reopen(port, clear, id, ref);
378         write_unlock(&adapter->erp_lock);
379         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
380
381         return retval;
382 }
383
384 static void zfcp_erp_unit_block(struct zfcp_unit *unit, int clear_mask)
385 {
386         zfcp_erp_modify_unit_status(unit, 19, NULL,
387                                     ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask,
388                                     ZFCP_CLEAR);
389 }
390
391 static void _zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id,
392                                   void *ref)
393 {
394         struct zfcp_adapter *adapter = unit->port->adapter;
395
396         zfcp_erp_unit_block(unit, clear);
397
398         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
399                 return;
400
401         zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_UNIT,
402                                 adapter, unit->port, unit, id, ref);
403 }
404
405 /**
406  * zfcp_erp_unit_reopen - initiate reopen of a unit
407  * @unit: unit to be reopened
408  * @clear_mask: specifies flags in unit status to be cleared
409  * Return: 0 on success, < 0 on error
410  */
411 void zfcp_erp_unit_reopen(struct zfcp_unit *unit, int clear, u8 id, void *ref)
412 {
413         unsigned long flags;
414         struct zfcp_port *port = unit->port;
415         struct zfcp_adapter *adapter = port->adapter;
416
417         read_lock_irqsave(&zfcp_data.config_lock, flags);
418         write_lock(&adapter->erp_lock);
419         _zfcp_erp_unit_reopen(unit, clear, id, ref);
420         write_unlock(&adapter->erp_lock);
421         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
422 }
423
424 static int status_change_set(unsigned long mask, atomic_t *status)
425 {
426         return (atomic_read(status) ^ mask) & mask;
427 }
428
429 static int status_change_clear(unsigned long mask, atomic_t *status)
430 {
431         return atomic_read(status) & mask;
432 }
433
434 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
435 {
436         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status))
437                 zfcp_rec_dbf_event_adapter(16, NULL, adapter);
438         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
439 }
440
441 static void zfcp_erp_port_unblock(struct zfcp_port *port)
442 {
443         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status))
444                 zfcp_rec_dbf_event_port(18, NULL, port);
445         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
446 }
447
448 static void zfcp_erp_unit_unblock(struct zfcp_unit *unit)
449 {
450         if (status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status))
451                 zfcp_rec_dbf_event_unit(20, NULL, unit);
452         atomic_set_mask(ZFCP_STATUS_COMMON_UNBLOCKED, &unit->status);
453 }
454
455 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
456 {
457         list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
458         zfcp_rec_dbf_event_action(145, erp_action);
459 }
460
461 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
462 {
463         struct zfcp_adapter *adapter = act->adapter;
464
465         if (!act->fsf_req)
466                 return;
467
468         spin_lock(&adapter->req_list_lock);
469         if (zfcp_reqlist_find_safe(adapter, act->fsf_req) &&
470             act->fsf_req->erp_action == act) {
471                 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
472                                    ZFCP_STATUS_ERP_TIMEDOUT)) {
473                         act->fsf_req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
474                         zfcp_rec_dbf_event_action(142, act);
475                         act->fsf_req->erp_action = NULL;
476                 }
477                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
478                         zfcp_rec_dbf_event_action(143, act);
479                 if (act->fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED |
480                                             ZFCP_STATUS_FSFREQ_DISMISSED))
481                         act->fsf_req = NULL;
482         } else
483                 act->fsf_req = NULL;
484         spin_unlock(&adapter->req_list_lock);
485 }
486
487 /**
488  * zfcp_erp_notify - Trigger ERP action.
489  * @erp_action: ERP action to continue.
490  * @set_mask: ERP action status flags to set.
491  */
492 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
493 {
494         struct zfcp_adapter *adapter = erp_action->adapter;
495         unsigned long flags;
496
497         write_lock_irqsave(&adapter->erp_lock, flags);
498         if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
499                 erp_action->status |= set_mask;
500                 zfcp_erp_action_ready(erp_action);
501         }
502         write_unlock_irqrestore(&adapter->erp_lock, flags);
503 }
504
505 /**
506  * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
507  * @data: ERP action (from timer data)
508  */
509 void zfcp_erp_timeout_handler(unsigned long data)
510 {
511         struct zfcp_erp_action *act = (struct zfcp_erp_action *) data;
512         zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
513 }
514
515 static void zfcp_erp_memwait_handler(unsigned long data)
516 {
517         zfcp_erp_notify((struct zfcp_erp_action *)data, 0);
518 }
519
520 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
521 {
522         init_timer(&erp_action->timer);
523         erp_action->timer.function = zfcp_erp_memwait_handler;
524         erp_action->timer.data = (unsigned long) erp_action;
525         erp_action->timer.expires = jiffies + HZ;
526         add_timer(&erp_action->timer);
527 }
528
529 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
530                                       int clear, u8 id, void *ref)
531 {
532         struct zfcp_port *port;
533
534         list_for_each_entry(port, &adapter->port_list_head, list)
535                 _zfcp_erp_port_reopen(port, clear, id, ref);
536 }
537
538 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id,
539                                       void *ref)
540 {
541         struct zfcp_unit *unit;
542
543         list_for_each_entry(unit, &port->unit_list_head, list)
544                 _zfcp_erp_unit_reopen(unit, clear, id, ref);
545 }
546
547 static void zfcp_erp_strategy_followup_actions(struct zfcp_erp_action *act)
548 {
549         struct zfcp_adapter *adapter = act->adapter;
550         struct zfcp_port *port = act->port;
551         struct zfcp_unit *unit = act->unit;
552         u32 status = act->status;
553
554         /* initiate follow-up actions depending on success of finished action */
555         switch (act->action) {
556
557         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
558                 if (status == ZFCP_ERP_SUCCEEDED)
559                         _zfcp_erp_port_reopen_all(adapter, 0, 70, NULL);
560                 else
561                         _zfcp_erp_adapter_reopen(adapter, 0, 71, NULL);
562                 break;
563
564         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
565                 if (status == ZFCP_ERP_SUCCEEDED)
566                         _zfcp_erp_port_reopen(port, 0, 72, NULL);
567                 else
568                         _zfcp_erp_adapter_reopen(adapter, 0, 73, NULL);
569                 break;
570
571         case ZFCP_ERP_ACTION_REOPEN_PORT:
572                 if (status == ZFCP_ERP_SUCCEEDED)
573                         _zfcp_erp_unit_reopen_all(port, 0, 74, NULL);
574                 else
575                         _zfcp_erp_port_forced_reopen(port, 0, 75, NULL);
576                 break;
577
578         case ZFCP_ERP_ACTION_REOPEN_UNIT:
579                 if (status != ZFCP_ERP_SUCCEEDED)
580                         _zfcp_erp_port_reopen(unit->port, 0, 76, NULL);
581                 break;
582         }
583 }
584
585 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
586 {
587         unsigned long flags;
588
589         read_lock_irqsave(&zfcp_data.config_lock, flags);
590         read_lock(&adapter->erp_lock);
591         if (list_empty(&adapter->erp_ready_head) &&
592             list_empty(&adapter->erp_running_head)) {
593                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
594                                           &adapter->status);
595                         wake_up(&adapter->erp_done_wqh);
596         }
597         read_unlock(&adapter->erp_lock);
598         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
599 }
600
601 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
602 {
603         if (zfcp_qdio_open(act->adapter))
604                 return ZFCP_ERP_FAILED;
605         init_waitqueue_head(&act->adapter->request_wq);
606         atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
607         return ZFCP_ERP_SUCCEEDED;
608 }
609
610 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
611 {
612         struct zfcp_port *port;
613         port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
614                                  adapter->peer_d_id);
615         if (IS_ERR(port)) /* error or port already attached */
616                 return;
617         _zfcp_erp_port_reopen(port, 0, 150, NULL);
618 }
619
620 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
621 {
622         int retries;
623         int sleep = 1;
624         struct zfcp_adapter *adapter = erp_action->adapter;
625
626         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
627
628         for (retries = 7; retries; retries--) {
629                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
630                                   &adapter->status);
631                 write_lock_irq(&adapter->erp_lock);
632                 zfcp_erp_action_to_running(erp_action);
633                 write_unlock_irq(&adapter->erp_lock);
634                 if (zfcp_fsf_exchange_config_data(erp_action)) {
635                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
636                                           &adapter->status);
637                         return ZFCP_ERP_FAILED;
638                 }
639
640                 zfcp_rec_dbf_event_thread_lock(6, adapter);
641                 down(&adapter->erp_ready_sem);
642                 zfcp_rec_dbf_event_thread_lock(7, adapter);
643                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
644                         break;
645
646                 if (!(atomic_read(&adapter->status) &
647                       ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
648                         break;
649
650                 ssleep(sleep);
651                 sleep *= 2;
652         }
653
654         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
655                           &adapter->status);
656
657         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
658                 return ZFCP_ERP_FAILED;
659
660         if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
661                 zfcp_erp_enqueue_ptp_port(adapter);
662
663         return ZFCP_ERP_SUCCEEDED;
664 }
665
666 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
667 {
668         int ret;
669         struct zfcp_adapter *adapter = act->adapter;
670
671         write_lock_irq(&adapter->erp_lock);
672         zfcp_erp_action_to_running(act);
673         write_unlock_irq(&adapter->erp_lock);
674
675         ret = zfcp_fsf_exchange_port_data(act);
676         if (ret == -EOPNOTSUPP)
677                 return ZFCP_ERP_SUCCEEDED;
678         if (ret)
679                 return ZFCP_ERP_FAILED;
680
681         zfcp_rec_dbf_event_thread_lock(8, adapter);
682         down(&adapter->erp_ready_sem);
683         zfcp_rec_dbf_event_thread_lock(9, adapter);
684         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
685                 return ZFCP_ERP_FAILED;
686
687         return ZFCP_ERP_SUCCEEDED;
688 }
689
690 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
691 {
692         if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
693                 return ZFCP_ERP_FAILED;
694
695         if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
696                 return ZFCP_ERP_FAILED;
697
698         atomic_set(&act->adapter->stat_miss, 16);
699         if (zfcp_status_read_refill(act->adapter))
700                 return ZFCP_ERP_FAILED;
701
702         return ZFCP_ERP_SUCCEEDED;
703 }
704
705 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *act,
706                                              int close)
707 {
708         int retval = ZFCP_ERP_SUCCEEDED;
709         struct zfcp_adapter *adapter = act->adapter;
710
711         if (close)
712                 goto close_only;
713
714         retval = zfcp_erp_adapter_strategy_open_qdio(act);
715         if (retval != ZFCP_ERP_SUCCEEDED)
716                 goto failed_qdio;
717
718         retval = zfcp_erp_adapter_strategy_open_fsf(act);
719         if (retval != ZFCP_ERP_SUCCEEDED)
720                 goto failed_openfcp;
721
722         atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &act->adapter->status);
723         schedule_work(&act->adapter->scan_work);
724
725         return ZFCP_ERP_SUCCEEDED;
726
727  close_only:
728         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
729                           &act->adapter->status);
730
731  failed_openfcp:
732         /* close queues to ensure that buffers are not accessed by adapter */
733         zfcp_qdio_close(adapter);
734         zfcp_fsf_req_dismiss_all(adapter);
735         adapter->fsf_req_seq_no = 0;
736         /* all ports and units are closed */
737         zfcp_erp_modify_adapter_status(adapter, 24, NULL,
738                                        ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
739  failed_qdio:
740         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
741                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
742                           &act->adapter->status);
743         return retval;
744 }
745
746 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
747 {
748         int retval;
749
750         zfcp_erp_adapter_strategy_generic(act, 1); /* close */
751         if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
752                 return ZFCP_ERP_EXIT;
753
754         retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */
755
756         if (retval == ZFCP_ERP_FAILED)
757                 ssleep(8);
758
759         return retval;
760 }
761
762 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
763 {
764         int retval;
765
766         retval = zfcp_fsf_close_physical_port(act);
767         if (retval == -ENOMEM)
768                 return ZFCP_ERP_NOMEM;
769         act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
770         if (retval)
771                 return ZFCP_ERP_FAILED;
772
773         return ZFCP_ERP_CONTINUES;
774 }
775
776 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
777 {
778         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
779                           ZFCP_STATUS_PORT_PHYS_CLOSING |
780                           ZFCP_STATUS_PORT_INVALID_WWPN,
781                           &port->status);
782 }
783
784 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
785 {
786         struct zfcp_port *port = erp_action->port;
787         int status = atomic_read(&port->status);
788
789         switch (erp_action->step) {
790         case ZFCP_ERP_STEP_UNINITIALIZED:
791                 zfcp_erp_port_strategy_clearstati(port);
792                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
793                     (status & ZFCP_STATUS_COMMON_OPEN))
794                         return zfcp_erp_port_forced_strategy_close(erp_action);
795                 else
796                         return ZFCP_ERP_FAILED;
797
798         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
799                 if (status & ZFCP_STATUS_PORT_PHYS_OPEN)
800                         return ZFCP_ERP_SUCCEEDED;
801         }
802         return ZFCP_ERP_FAILED;
803 }
804
805 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
806 {
807         int retval;
808
809         retval = zfcp_fsf_close_port(erp_action);
810         if (retval == -ENOMEM)
811                 return ZFCP_ERP_NOMEM;
812         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
813         if (retval)
814                 return ZFCP_ERP_FAILED;
815         return ZFCP_ERP_CONTINUES;
816 }
817
818 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
819 {
820         int retval;
821
822         retval = zfcp_fsf_open_port(erp_action);
823         if (retval == -ENOMEM)
824                 return ZFCP_ERP_NOMEM;
825         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
826         if (retval)
827                 return ZFCP_ERP_FAILED;
828         return ZFCP_ERP_CONTINUES;
829 }
830
831 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
832 {
833         struct zfcp_adapter *adapter = act->adapter;
834         struct zfcp_port *port = act->port;
835
836         if (port->wwpn != adapter->peer_wwpn) {
837                 zfcp_erp_port_failed(port, 25, NULL);
838                 return ZFCP_ERP_FAILED;
839         }
840         port->d_id = adapter->peer_d_id;
841         atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
842         return zfcp_erp_port_strategy_open_port(act);
843 }
844
845 void zfcp_erp_port_strategy_open_lookup(struct work_struct *work)
846 {
847         int retval;
848         struct zfcp_port *port = container_of(work, struct zfcp_port,
849                                               gid_pn_work);
850
851         retval = zfcp_fc_ns_gid_pn(&port->erp_action);
852         if (retval == -ENOMEM)
853                 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM);
854         port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
855         if (retval)
856                 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED);
857
858 }
859
860 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
861 {
862         struct zfcp_adapter *adapter = act->adapter;
863         struct zfcp_port *port = act->port;
864         int p_status = atomic_read(&port->status);
865
866         switch (act->step) {
867         case ZFCP_ERP_STEP_UNINITIALIZED:
868         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
869         case ZFCP_ERP_STEP_PORT_CLOSING:
870                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
871                         return zfcp_erp_open_ptp_port(act);
872                 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
873                         queue_work(zfcp_data.work_queue, &port->gid_pn_work);
874                         return ZFCP_ERP_CONTINUES;
875                 }
876         case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
877                 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
878                         if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) {
879                                 zfcp_erp_port_failed(port, 26, NULL);
880                                 return ZFCP_ERP_EXIT;
881                         }
882                         return ZFCP_ERP_FAILED;
883                 }
884                 return zfcp_erp_port_strategy_open_port(act);
885
886         case ZFCP_ERP_STEP_PORT_OPENING:
887                 /* D_ID might have changed during open */
888                 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
889                         if (p_status & ZFCP_STATUS_PORT_DID_DID)
890                                 return ZFCP_ERP_SUCCEEDED;
891                         else {
892                                 act->step = ZFCP_ERP_STEP_PORT_CLOSING;
893                                 return ZFCP_ERP_CONTINUES;
894                         }
895                 /* fall through otherwise */
896                 }
897         }
898         return ZFCP_ERP_FAILED;
899 }
900
901 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
902 {
903         struct zfcp_port *port = erp_action->port;
904
905         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)
906                 goto close_init_done;
907
908         switch (erp_action->step) {
909         case ZFCP_ERP_STEP_UNINITIALIZED:
910                 zfcp_erp_port_strategy_clearstati(port);
911                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
912                         return zfcp_erp_port_strategy_close(erp_action);
913                 break;
914
915         case ZFCP_ERP_STEP_PORT_CLOSING:
916                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
917                         return ZFCP_ERP_FAILED;
918                 break;
919         }
920
921 close_init_done:
922         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
923                 return ZFCP_ERP_EXIT;
924
925         return zfcp_erp_port_strategy_open_common(erp_action);
926 }
927
928 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
929 {
930         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
931                           ZFCP_STATUS_UNIT_SHARED |
932                           ZFCP_STATUS_UNIT_READONLY,
933                           &unit->status);
934 }
935
936 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
937 {
938         int retval = zfcp_fsf_close_unit(erp_action);
939         if (retval == -ENOMEM)
940                 return ZFCP_ERP_NOMEM;
941         erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
942         if (retval)
943                 return ZFCP_ERP_FAILED;
944         return ZFCP_ERP_CONTINUES;
945 }
946
947 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
948 {
949         int retval = zfcp_fsf_open_unit(erp_action);
950         if (retval == -ENOMEM)
951                 return ZFCP_ERP_NOMEM;
952         erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
953         if (retval)
954                 return  ZFCP_ERP_FAILED;
955         return ZFCP_ERP_CONTINUES;
956 }
957
958 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
959 {
960         struct zfcp_unit *unit = erp_action->unit;
961
962         switch (erp_action->step) {
963         case ZFCP_ERP_STEP_UNINITIALIZED:
964                 zfcp_erp_unit_strategy_clearstati(unit);
965                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
966                         return zfcp_erp_unit_strategy_close(erp_action);
967                 /* already closed, fall through */
968         case ZFCP_ERP_STEP_UNIT_CLOSING:
969                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
970                         return ZFCP_ERP_FAILED;
971                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
972                         return ZFCP_ERP_EXIT;
973                 return zfcp_erp_unit_strategy_open(erp_action);
974
975         case ZFCP_ERP_STEP_UNIT_OPENING:
976                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
977                         return ZFCP_ERP_SUCCEEDED;
978         }
979         return ZFCP_ERP_FAILED;
980 }
981
982 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
983 {
984         switch (result) {
985         case ZFCP_ERP_SUCCEEDED :
986                 atomic_set(&unit->erp_counter, 0);
987                 zfcp_erp_unit_unblock(unit);
988                 break;
989         case ZFCP_ERP_FAILED :
990                 atomic_inc(&unit->erp_counter);
991                 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
992                         dev_err(&unit->port->adapter->ccw_device->dev,
993                                 "ERP failed for unit 0x%016Lx on "
994                                 "port 0x%016Lx\n",
995                                 (unsigned long long)unit->fcp_lun,
996                                 (unsigned long long)unit->port->wwpn);
997                         zfcp_erp_unit_failed(unit, 21, NULL);
998                 }
999                 break;
1000         }
1001
1002         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1003                 zfcp_erp_unit_block(unit, 0);
1004                 result = ZFCP_ERP_EXIT;
1005         }
1006         return result;
1007 }
1008
1009 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1010 {
1011         switch (result) {
1012         case ZFCP_ERP_SUCCEEDED :
1013                 atomic_set(&port->erp_counter, 0);
1014                 zfcp_erp_port_unblock(port);
1015                 break;
1016
1017         case ZFCP_ERP_FAILED :
1018                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1019                         zfcp_erp_port_block(port, 0);
1020                         result = ZFCP_ERP_EXIT;
1021                 }
1022                 atomic_inc(&port->erp_counter);
1023                 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1024                         dev_err(&port->adapter->ccw_device->dev,
1025                                 "ERP failed for remote port 0x%016Lx\n",
1026                                 (unsigned long long)port->wwpn);
1027                         zfcp_erp_port_failed(port, 22, NULL);
1028                 }
1029                 break;
1030         }
1031
1032         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1033                 zfcp_erp_port_block(port, 0);
1034                 result = ZFCP_ERP_EXIT;
1035         }
1036         return result;
1037 }
1038
1039 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1040                                            int result)
1041 {
1042         switch (result) {
1043         case ZFCP_ERP_SUCCEEDED :
1044                 atomic_set(&adapter->erp_counter, 0);
1045                 zfcp_erp_adapter_unblock(adapter);
1046                 break;
1047
1048         case ZFCP_ERP_FAILED :
1049                 atomic_inc(&adapter->erp_counter);
1050                 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1051                         dev_err(&adapter->ccw_device->dev,
1052                                 "ERP cannot recover an error "
1053                                 "on the FCP device\n");
1054                         zfcp_erp_adapter_failed(adapter, 23, NULL);
1055                 }
1056                 break;
1057         }
1058
1059         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1060                 zfcp_erp_adapter_block(adapter, 0);
1061                 result = ZFCP_ERP_EXIT;
1062         }
1063         return result;
1064 }
1065
1066 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1067                                           int result)
1068 {
1069         struct zfcp_adapter *adapter = erp_action->adapter;
1070         struct zfcp_port *port = erp_action->port;
1071         struct zfcp_unit *unit = erp_action->unit;
1072
1073         switch (erp_action->action) {
1074
1075         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1076                 result = zfcp_erp_strategy_check_unit(unit, result);
1077                 break;
1078
1079         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1080         case ZFCP_ERP_ACTION_REOPEN_PORT:
1081                 result = zfcp_erp_strategy_check_port(port, result);
1082                 break;
1083
1084         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1085                 result = zfcp_erp_strategy_check_adapter(adapter, result);
1086                 break;
1087         }
1088         return result;
1089 }
1090
1091 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1092 {
1093         int status = atomic_read(target_status);
1094
1095         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1096             (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1097                 return 1; /* take it online */
1098
1099         if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1100             !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1101                 return 1; /* take it offline */
1102
1103         return 0;
1104 }
1105
1106 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1107 {
1108         int action = act->action;
1109         struct zfcp_adapter *adapter = act->adapter;
1110         struct zfcp_port *port = act->port;
1111         struct zfcp_unit *unit = act->unit;
1112         u32 erp_status = act->status;
1113
1114         switch (action) {
1115         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1116                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1117                         _zfcp_erp_adapter_reopen(adapter,
1118                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
1119                                                  67, NULL);
1120                         return ZFCP_ERP_EXIT;
1121                 }
1122                 break;
1123
1124         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1125         case ZFCP_ERP_ACTION_REOPEN_PORT:
1126                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1127                         _zfcp_erp_port_reopen(port,
1128                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1129                                               68, NULL);
1130                         return ZFCP_ERP_EXIT;
1131                 }
1132                 break;
1133
1134         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1135                 if (zfcp_erp_strat_change_det(&unit->status, erp_status)) {
1136                         _zfcp_erp_unit_reopen(unit,
1137                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1138                                               69, NULL);
1139                         return ZFCP_ERP_EXIT;
1140                 }
1141                 break;
1142         }
1143         return ret;
1144 }
1145
1146 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1147 {
1148         struct zfcp_adapter *adapter = erp_action->adapter;
1149
1150         adapter->erp_total_count--;
1151         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1152                 adapter->erp_low_mem_count--;
1153                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1154         }
1155
1156         list_del(&erp_action->list);
1157         zfcp_rec_dbf_event_action(144, erp_action);
1158
1159         switch (erp_action->action) {
1160         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1161                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1162                                   &erp_action->unit->status);
1163                 break;
1164
1165         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1166         case ZFCP_ERP_ACTION_REOPEN_PORT:
1167                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1168                                   &erp_action->port->status);
1169                 break;
1170
1171         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1172                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1173                                   &erp_action->adapter->status);
1174                 break;
1175         }
1176 }
1177
1178 struct zfcp_erp_add_work {
1179         struct zfcp_unit  *unit;
1180         struct work_struct work;
1181 };
1182
1183 static void zfcp_erp_scsi_scan(struct work_struct *work)
1184 {
1185         struct zfcp_erp_add_work *p =
1186                 container_of(work, struct zfcp_erp_add_work, work);
1187         struct zfcp_unit *unit = p->unit;
1188         struct fc_rport *rport = unit->port->rport;
1189         scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
1190                          scsilun_to_int((struct scsi_lun *)&unit->fcp_lun), 0);
1191         atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1192         zfcp_unit_put(unit);
1193         wake_up(&unit->port->adapter->erp_done_wqh);
1194         kfree(p);
1195 }
1196
1197 static void zfcp_erp_schedule_work(struct zfcp_unit *unit)
1198 {
1199         struct zfcp_erp_add_work *p;
1200
1201         p = kzalloc(sizeof(*p), GFP_KERNEL);
1202         if (!p) {
1203                 dev_err(&unit->port->adapter->ccw_device->dev,
1204                         "Registering unit 0x%016Lx on port 0x%016Lx failed\n",
1205                         (unsigned long long)unit->fcp_lun,
1206                         (unsigned long long)unit->port->wwpn);
1207                 return;
1208         }
1209
1210         zfcp_unit_get(unit);
1211         atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1212         INIT_WORK(&p->work, zfcp_erp_scsi_scan);
1213         p->unit = unit;
1214         queue_work(zfcp_data.work_queue, &p->work);
1215 }
1216
1217 static void zfcp_erp_rport_register(struct zfcp_port *port)
1218 {
1219         struct fc_rport_identifiers ids;
1220         ids.node_name = port->wwnn;
1221         ids.port_name = port->wwpn;
1222         ids.port_id = port->d_id;
1223         ids.roles = FC_RPORT_ROLE_FCP_TARGET;
1224         port->rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
1225         if (!port->rport) {
1226                 dev_err(&port->adapter->ccw_device->dev,
1227                         "Registering port 0x%016Lx failed\n",
1228                         (unsigned long long)port->wwpn);
1229                 return;
1230         }
1231
1232         scsi_target_unblock(&port->rport->dev);
1233         port->rport->maxframe_size = port->maxframe_size;
1234         port->rport->supported_classes = port->supported_classes;
1235 }
1236
1237 static void zfcp_erp_rports_del(struct zfcp_adapter *adapter)
1238 {
1239         struct zfcp_port *port;
1240         list_for_each_entry(port, &adapter->port_list_head, list) {
1241                 if (!port->rport)
1242                         continue;
1243                 fc_remote_port_delete(port->rport);
1244                 port->rport = NULL;
1245         }
1246 }
1247
1248 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1249 {
1250         struct zfcp_adapter *adapter = act->adapter;
1251         struct zfcp_port *port = act->port;
1252         struct zfcp_unit *unit = act->unit;
1253
1254         switch (act->action) {
1255         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1256                 if ((result == ZFCP_ERP_SUCCEEDED) &&
1257                     !unit->device && port->rport) {
1258                         atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
1259                                         &unit->status);
1260                         if (!(atomic_read(&unit->status) &
1261                               ZFCP_STATUS_UNIT_SCSI_WORK_PENDING))
1262                                 zfcp_erp_schedule_work(unit);
1263                 }
1264                 zfcp_unit_put(unit);
1265                 break;
1266
1267         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1268         case ZFCP_ERP_ACTION_REOPEN_PORT:
1269                 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN) {
1270                         zfcp_port_put(port);
1271                         return;
1272                 }
1273                 if ((result == ZFCP_ERP_SUCCEEDED) && !port->rport)
1274                         zfcp_erp_rport_register(port);
1275                 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
1276                         fc_remote_port_delete(port->rport);
1277                         port->rport = NULL;
1278                 }
1279                 zfcp_port_put(port);
1280                 break;
1281
1282         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1283                 if (result != ZFCP_ERP_SUCCEEDED)
1284                         zfcp_erp_rports_del(adapter);
1285                 zfcp_adapter_put(adapter);
1286                 break;
1287         }
1288 }
1289
1290 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1291 {
1292         switch (erp_action->action) {
1293         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1294                 return zfcp_erp_adapter_strategy(erp_action);
1295         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1296                 return zfcp_erp_port_forced_strategy(erp_action);
1297         case ZFCP_ERP_ACTION_REOPEN_PORT:
1298                 return zfcp_erp_port_strategy(erp_action);
1299         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1300                 return zfcp_erp_unit_strategy(erp_action);
1301         }
1302         return ZFCP_ERP_FAILED;
1303 }
1304
1305 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1306 {
1307         int retval;
1308         struct zfcp_adapter *adapter = erp_action->adapter;
1309         unsigned long flags;
1310
1311         read_lock_irqsave(&zfcp_data.config_lock, flags);
1312         write_lock(&adapter->erp_lock);
1313
1314         zfcp_erp_strategy_check_fsfreq(erp_action);
1315
1316         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1317                 zfcp_erp_action_dequeue(erp_action);
1318                 retval = ZFCP_ERP_DISMISSED;
1319                 goto unlock;
1320         }
1321
1322         zfcp_erp_action_to_running(erp_action);
1323
1324         /* no lock to allow for blocking operations */
1325         write_unlock(&adapter->erp_lock);
1326         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1327         retval = zfcp_erp_strategy_do_action(erp_action);
1328         read_lock_irqsave(&zfcp_data.config_lock, flags);
1329         write_lock(&adapter->erp_lock);
1330
1331         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1332                 retval = ZFCP_ERP_CONTINUES;
1333
1334         switch (retval) {
1335         case ZFCP_ERP_NOMEM:
1336                 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1337                         ++adapter->erp_low_mem_count;
1338                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1339                 }
1340                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1341                         _zfcp_erp_adapter_reopen(adapter, 0, 66, NULL);
1342                 else {
1343                         zfcp_erp_strategy_memwait(erp_action);
1344                         retval = ZFCP_ERP_CONTINUES;
1345                 }
1346                 goto unlock;
1347
1348         case ZFCP_ERP_CONTINUES:
1349                 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1350                         --adapter->erp_low_mem_count;
1351                         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1352                 }
1353                 goto unlock;
1354         }
1355
1356         retval = zfcp_erp_strategy_check_target(erp_action, retval);
1357         zfcp_erp_action_dequeue(erp_action);
1358         retval = zfcp_erp_strategy_statechange(erp_action, retval);
1359         if (retval == ZFCP_ERP_EXIT)
1360                 goto unlock;
1361         zfcp_erp_strategy_followup_actions(erp_action);
1362
1363  unlock:
1364         write_unlock(&adapter->erp_lock);
1365         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1366
1367         if (retval != ZFCP_ERP_CONTINUES)
1368                 zfcp_erp_action_cleanup(erp_action, retval);
1369
1370         return retval;
1371 }
1372
1373 static int zfcp_erp_thread(void *data)
1374 {
1375         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1376         struct list_head *next;
1377         struct zfcp_erp_action *act;
1378         unsigned long flags;
1379
1380         daemonize("zfcperp%s", dev_name(&adapter->ccw_device->dev));
1381         /* Block all signals */
1382         siginitsetinv(&current->blocked, 0);
1383         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1384         wake_up(&adapter->erp_thread_wqh);
1385
1386         while (!(atomic_read(&adapter->status) &
1387                  ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL)) {
1388                 write_lock_irqsave(&adapter->erp_lock, flags);
1389                 next = adapter->erp_ready_head.next;
1390                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1391
1392                 if (next != &adapter->erp_ready_head) {
1393                         act = list_entry(next, struct zfcp_erp_action, list);
1394
1395                         /* there is more to come after dismission, no notify */
1396                         if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1397                                 zfcp_erp_wakeup(adapter);
1398                 }
1399
1400                 zfcp_rec_dbf_event_thread_lock(4, adapter);
1401                 down_interruptible(&adapter->erp_ready_sem);
1402                 zfcp_rec_dbf_event_thread_lock(5, adapter);
1403         }
1404
1405         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1406         wake_up(&adapter->erp_thread_wqh);
1407
1408         return 0;
1409 }
1410
1411 /**
1412  * zfcp_erp_thread_setup - Start ERP thread for adapter
1413  * @adapter: Adapter to start the ERP thread for
1414  *
1415  * Returns 0 on success or error code from kernel_thread()
1416  */
1417 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1418 {
1419         int retval;
1420
1421         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1422         retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
1423         if (retval < 0) {
1424                 dev_err(&adapter->ccw_device->dev,
1425                         "Creating an ERP thread for the FCP device failed.\n");
1426                 return retval;
1427         }
1428         wait_event(adapter->erp_thread_wqh,
1429                    atomic_read(&adapter->status) &
1430                         ZFCP_STATUS_ADAPTER_ERP_THREAD_UP);
1431         return 0;
1432 }
1433
1434 /**
1435  * zfcp_erp_thread_kill - Stop ERP thread.
1436  * @adapter: Adapter where the ERP thread should be stopped.
1437  *
1438  * The caller of this routine ensures that the specified adapter has
1439  * been shut down and that this operation has been completed. Thus,
1440  * there are no pending erp_actions which would need to be handled
1441  * here.
1442  */
1443 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1444 {
1445         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1446         up(&adapter->erp_ready_sem);
1447         zfcp_rec_dbf_event_thread_lock(3, adapter);
1448
1449         wait_event(adapter->erp_thread_wqh,
1450                    !(atomic_read(&adapter->status) &
1451                                 ZFCP_STATUS_ADAPTER_ERP_THREAD_UP));
1452
1453         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1454                           &adapter->status);
1455 }
1456
1457 /**
1458  * zfcp_erp_adapter_failed - Set adapter status to failed.
1459  * @adapter: Failed adapter.
1460  * @id: Event id for debug trace.
1461  * @ref: Reference for debug trace.
1462  */
1463 void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, void *ref)
1464 {
1465         zfcp_erp_modify_adapter_status(adapter, id, ref,
1466                                        ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1467 }
1468
1469 /**
1470  * zfcp_erp_port_failed - Set port status to failed.
1471  * @port: Failed port.
1472  * @id: Event id for debug trace.
1473  * @ref: Reference for debug trace.
1474  */
1475 void zfcp_erp_port_failed(struct zfcp_port *port, u8 id, void *ref)
1476 {
1477         zfcp_erp_modify_port_status(port, id, ref,
1478                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1479 }
1480
1481 /**
1482  * zfcp_erp_unit_failed - Set unit status to failed.
1483  * @unit: Failed unit.
1484  * @id: Event id for debug trace.
1485  * @ref: Reference for debug trace.
1486  */
1487 void zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, void *ref)
1488 {
1489         zfcp_erp_modify_unit_status(unit, id, ref,
1490                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1491 }
1492
1493 /**
1494  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1495  * @adapter: adapter for which to wait for completion of its error recovery
1496  */
1497 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1498 {
1499         wait_event(adapter->erp_done_wqh,
1500                    !(atomic_read(&adapter->status) &
1501                         ZFCP_STATUS_ADAPTER_ERP_PENDING));
1502 }
1503
1504 /**
1505  * zfcp_erp_modify_adapter_status - change adapter status bits
1506  * @adapter: adapter to change the status
1507  * @id: id for the debug trace
1508  * @ref: reference for the debug trace
1509  * @mask: status bits to change
1510  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1511  *
1512  * Changes in common status bits are propagated to attached ports and units.
1513  */
1514 void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, u8 id,
1515                                     void *ref, u32 mask, int set_or_clear)
1516 {
1517         struct zfcp_port *port;
1518         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1519
1520         if (set_or_clear == ZFCP_SET) {
1521                 if (status_change_set(mask, &adapter->status))
1522                         zfcp_rec_dbf_event_adapter(id, ref, adapter);
1523                 atomic_set_mask(mask, &adapter->status);
1524         } else {
1525                 if (status_change_clear(mask, &adapter->status))
1526                         zfcp_rec_dbf_event_adapter(id, ref, adapter);
1527                 atomic_clear_mask(mask, &adapter->status);
1528                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1529                         atomic_set(&adapter->erp_counter, 0);
1530         }
1531
1532         if (common_mask)
1533                 list_for_each_entry(port, &adapter->port_list_head, list)
1534                         zfcp_erp_modify_port_status(port, id, ref, common_mask,
1535                                                     set_or_clear);
1536 }
1537
1538 /**
1539  * zfcp_erp_modify_port_status - change port status bits
1540  * @port: port to change the status bits
1541  * @id: id for the debug trace
1542  * @ref: reference for the debug trace
1543  * @mask: status bits to change
1544  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1545  *
1546  * Changes in common status bits are propagated to attached units.
1547  */
1548 void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, void *ref,
1549                                  u32 mask, int set_or_clear)
1550 {
1551         struct zfcp_unit *unit;
1552         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1553
1554         if (set_or_clear == ZFCP_SET) {
1555                 if (status_change_set(mask, &port->status))
1556                         zfcp_rec_dbf_event_port(id, ref, port);
1557                 atomic_set_mask(mask, &port->status);
1558         } else {
1559                 if (status_change_clear(mask, &port->status))
1560                         zfcp_rec_dbf_event_port(id, ref, port);
1561                 atomic_clear_mask(mask, &port->status);
1562                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1563                         atomic_set(&port->erp_counter, 0);
1564         }
1565
1566         if (common_mask)
1567                 list_for_each_entry(unit, &port->unit_list_head, list)
1568                         zfcp_erp_modify_unit_status(unit, id, ref, common_mask,
1569                                                     set_or_clear);
1570 }
1571
1572 /**
1573  * zfcp_erp_modify_unit_status - change unit status bits
1574  * @unit: unit to change the status bits
1575  * @id: id for the debug trace
1576  * @ref: reference for the debug trace
1577  * @mask: status bits to change
1578  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1579  */
1580 void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, void *ref,
1581                                  u32 mask, int set_or_clear)
1582 {
1583         if (set_or_clear == ZFCP_SET) {
1584                 if (status_change_set(mask, &unit->status))
1585                         zfcp_rec_dbf_event_unit(id, ref, unit);
1586                 atomic_set_mask(mask, &unit->status);
1587         } else {
1588                 if (status_change_clear(mask, &unit->status))
1589                         zfcp_rec_dbf_event_unit(id, ref, unit);
1590                 atomic_clear_mask(mask, &unit->status);
1591                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1592                         atomic_set(&unit->erp_counter, 0);
1593                 }
1594         }
1595 }
1596
1597 /**
1598  * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
1599  * @port: The "boxed" port.
1600  * @id: The debug trace id.
1601  * @id: Reference for the debug trace.
1602  */
1603 void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref)
1604 {
1605         unsigned long flags;
1606
1607         read_lock_irqsave(&zfcp_data.config_lock, flags);
1608         zfcp_erp_modify_port_status(port, id, ref,
1609                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1610         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1611         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1612 }
1613
1614 /**
1615  * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
1616  * @port: The "boxed" unit.
1617  * @id: The debug trace id.
1618  * @id: Reference for the debug trace.
1619  */
1620 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref)
1621 {
1622         zfcp_erp_modify_unit_status(unit, id, ref,
1623                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1624         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1625 }
1626
1627 /**
1628  * zfcp_erp_port_access_denied - Adapter denied access to port.
1629  * @port: port where access has been denied
1630  * @id: id for debug trace
1631  * @ref: reference for debug trace
1632  *
1633  * Since the adapter has denied access, stop using the port and the
1634  * attached units.
1635  */
1636 void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref)
1637 {
1638         unsigned long flags;
1639
1640         read_lock_irqsave(&zfcp_data.config_lock, flags);
1641         zfcp_erp_modify_port_status(port, id, ref,
1642                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1643                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1644         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1645 }
1646
1647 /**
1648  * zfcp_erp_unit_access_denied - Adapter denied access to unit.
1649  * @unit: unit where access has been denied
1650  * @id: id for debug trace
1651  * @ref: reference for debug trace
1652  *
1653  * Since the adapter has denied access, stop using the unit.
1654  */
1655 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref)
1656 {
1657         zfcp_erp_modify_unit_status(unit, id, ref,
1658                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1659                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1660 }
1661
1662 static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id,
1663                                          void *ref)
1664 {
1665         int status = atomic_read(&unit->status);
1666         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1667                         ZFCP_STATUS_COMMON_ACCESS_BOXED)))
1668                 return;
1669
1670         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1671 }
1672
1673 static void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id,
1674                                          void *ref)
1675 {
1676         struct zfcp_unit *unit;
1677         int status = atomic_read(&port->status);
1678
1679         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1680                         ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
1681                 list_for_each_entry(unit, &port->unit_list_head, list)
1682                                     zfcp_erp_unit_access_changed(unit, id, ref);
1683                 return;
1684         }
1685
1686         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1687 }
1688
1689 /**
1690  * zfcp_erp_adapter_access_changed - Process change in adapter ACT
1691  * @adapter: Adapter where the Access Control Table (ACT) changed
1692  * @id: Id for debug trace
1693  * @ref: Reference for debug trace
1694  */
1695 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id,
1696                                      void *ref)
1697 {
1698         struct zfcp_port *port;
1699         unsigned long flags;
1700
1701         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
1702                 return;
1703
1704         read_lock_irqsave(&zfcp_data.config_lock, flags);
1705         list_for_each_entry(port, &adapter->port_list_head, list)
1706                 zfcp_erp_port_access_changed(port, id, ref);
1707         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1708 }