[SCSI] zfcp: remove all typedefs and replace them with standards
[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                 }
476                 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
477                         zfcp_rec_dbf_event_action(143, act);
478                 if (act->fsf_req->status & (ZFCP_STATUS_FSFREQ_COMPLETED |
479                                             ZFCP_STATUS_FSFREQ_DISMISSED))
480                         act->fsf_req = NULL;
481         } else
482                 act->fsf_req = NULL;
483         spin_unlock(&adapter->req_list_lock);
484 }
485
486 /**
487  * zfcp_erp_notify - Trigger ERP action.
488  * @erp_action: ERP action to continue.
489  * @set_mask: ERP action status flags to set.
490  */
491 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
492 {
493         struct zfcp_adapter *adapter = erp_action->adapter;
494         unsigned long flags;
495
496         write_lock_irqsave(&adapter->erp_lock, flags);
497         if (zfcp_erp_action_exists(erp_action) == ZFCP_ERP_ACTION_RUNNING) {
498                 erp_action->status |= set_mask;
499                 zfcp_erp_action_ready(erp_action);
500         }
501         write_unlock_irqrestore(&adapter->erp_lock, flags);
502 }
503
504 /**
505  * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
506  * @data: ERP action (from timer data)
507  */
508 void zfcp_erp_timeout_handler(unsigned long data)
509 {
510         struct zfcp_erp_action *act = (struct zfcp_erp_action *) data;
511         zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
512 }
513
514 static void zfcp_erp_memwait_handler(unsigned long data)
515 {
516         zfcp_erp_notify((struct zfcp_erp_action *)data, 0);
517 }
518
519 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
520 {
521         init_timer(&erp_action->timer);
522         erp_action->timer.function = zfcp_erp_memwait_handler;
523         erp_action->timer.data = (unsigned long) erp_action;
524         erp_action->timer.expires = jiffies + HZ;
525         add_timer(&erp_action->timer);
526 }
527
528 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
529                                       int clear, u8 id, void *ref)
530 {
531         struct zfcp_port *port;
532
533         list_for_each_entry(port, &adapter->port_list_head, list)
534                 _zfcp_erp_port_reopen(port, clear, id, ref);
535 }
536
537 static void _zfcp_erp_unit_reopen_all(struct zfcp_port *port, int clear, u8 id,
538                                       void *ref)
539 {
540         struct zfcp_unit *unit;
541
542         list_for_each_entry(unit, &port->unit_list_head, list)
543                 _zfcp_erp_unit_reopen(unit, clear, id, ref);
544 }
545
546 static void zfcp_erp_strategy_followup_actions(struct zfcp_erp_action *act)
547 {
548         struct zfcp_adapter *adapter = act->adapter;
549         struct zfcp_port *port = act->port;
550         struct zfcp_unit *unit = act->unit;
551         u32 status = act->status;
552
553         /* initiate follow-up actions depending on success of finished action */
554         switch (act->action) {
555
556         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
557                 if (status == ZFCP_ERP_SUCCEEDED)
558                         _zfcp_erp_port_reopen_all(adapter, 0, 70, NULL);
559                 else
560                         _zfcp_erp_adapter_reopen(adapter, 0, 71, NULL);
561                 break;
562
563         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
564                 if (status == ZFCP_ERP_SUCCEEDED)
565                         _zfcp_erp_port_reopen(port, 0, 72, NULL);
566                 else
567                         _zfcp_erp_adapter_reopen(adapter, 0, 73, NULL);
568                 break;
569
570         case ZFCP_ERP_ACTION_REOPEN_PORT:
571                 if (status == ZFCP_ERP_SUCCEEDED)
572                         _zfcp_erp_unit_reopen_all(port, 0, 74, NULL);
573                 else
574                         _zfcp_erp_port_forced_reopen(port, 0, 75, NULL);
575                 break;
576
577         case ZFCP_ERP_ACTION_REOPEN_UNIT:
578                 if (status != ZFCP_ERP_SUCCEEDED)
579                         _zfcp_erp_port_reopen(unit->port, 0, 76, NULL);
580                 break;
581         }
582 }
583
584 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
585 {
586         unsigned long flags;
587
588         read_lock_irqsave(&zfcp_data.config_lock, flags);
589         read_lock(&adapter->erp_lock);
590         if (list_empty(&adapter->erp_ready_head) &&
591             list_empty(&adapter->erp_running_head)) {
592                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_PENDING,
593                                           &adapter->status);
594                         wake_up(&adapter->erp_done_wqh);
595         }
596         read_unlock(&adapter->erp_lock);
597         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
598 }
599
600 static int zfcp_erp_adapter_strategy_open_qdio(struct zfcp_erp_action *act)
601 {
602         if (zfcp_qdio_open(act->adapter))
603                 return ZFCP_ERP_FAILED;
604         init_waitqueue_head(&act->adapter->request_wq);
605         atomic_set_mask(ZFCP_STATUS_ADAPTER_QDIOUP, &act->adapter->status);
606         return ZFCP_ERP_SUCCEEDED;
607 }
608
609 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
610 {
611         struct zfcp_port *port;
612         port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
613                                  adapter->peer_d_id);
614         if (IS_ERR(port)) /* error or port already attached */
615                 return;
616         _zfcp_erp_port_reopen(port, 0, 150, NULL);
617 }
618
619 static int zfcp_erp_adapter_strat_fsf_xconf(struct zfcp_erp_action *erp_action)
620 {
621         int retries;
622         int sleep = 1;
623         struct zfcp_adapter *adapter = erp_action->adapter;
624
625         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
626
627         for (retries = 7; retries; retries--) {
628                 atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
629                                   &adapter->status);
630                 write_lock_irq(&adapter->erp_lock);
631                 zfcp_erp_action_to_running(erp_action);
632                 write_unlock_irq(&adapter->erp_lock);
633                 if (zfcp_fsf_exchange_config_data(erp_action)) {
634                         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
635                                           &adapter->status);
636                         return ZFCP_ERP_FAILED;
637                 }
638
639                 zfcp_rec_dbf_event_thread_lock(6, adapter);
640                 down(&adapter->erp_ready_sem);
641                 zfcp_rec_dbf_event_thread_lock(7, adapter);
642                 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
643                         break;
644
645                 if (!(atomic_read(&adapter->status) &
646                       ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
647                         break;
648
649                 ssleep(sleep);
650                 sleep *= 2;
651         }
652
653         atomic_clear_mask(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
654                           &adapter->status);
655
656         if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
657                 return ZFCP_ERP_FAILED;
658
659         if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
660                 zfcp_erp_enqueue_ptp_port(adapter);
661
662         return ZFCP_ERP_SUCCEEDED;
663 }
664
665 static int zfcp_erp_adapter_strategy_open_fsf_xport(struct zfcp_erp_action *act)
666 {
667         int ret;
668         struct zfcp_adapter *adapter = act->adapter;
669
670         write_lock_irq(&adapter->erp_lock);
671         zfcp_erp_action_to_running(act);
672         write_unlock_irq(&adapter->erp_lock);
673
674         ret = zfcp_fsf_exchange_port_data(act);
675         if (ret == -EOPNOTSUPP)
676                 return ZFCP_ERP_SUCCEEDED;
677         if (ret)
678                 return ZFCP_ERP_FAILED;
679
680         zfcp_rec_dbf_event_thread_lock(8, adapter);
681         down(&adapter->erp_ready_sem);
682         zfcp_rec_dbf_event_thread_lock(9, adapter);
683         if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
684                 return ZFCP_ERP_FAILED;
685
686         return ZFCP_ERP_SUCCEEDED;
687 }
688
689 static int zfcp_erp_adapter_strategy_open_fsf(struct zfcp_erp_action *act)
690 {
691         if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
692                 return ZFCP_ERP_FAILED;
693
694         if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
695                 return ZFCP_ERP_FAILED;
696
697         atomic_set(&act->adapter->stat_miss, 16);
698         if (zfcp_status_read_refill(act->adapter))
699                 return ZFCP_ERP_FAILED;
700
701         return ZFCP_ERP_SUCCEEDED;
702 }
703
704 static int zfcp_erp_adapter_strategy_generic(struct zfcp_erp_action *act,
705                                              int close)
706 {
707         int retval = ZFCP_ERP_SUCCEEDED;
708         struct zfcp_adapter *adapter = act->adapter;
709
710         if (close)
711                 goto close_only;
712
713         retval = zfcp_erp_adapter_strategy_open_qdio(act);
714         if (retval != ZFCP_ERP_SUCCEEDED)
715                 goto failed_qdio;
716
717         retval = zfcp_erp_adapter_strategy_open_fsf(act);
718         if (retval != ZFCP_ERP_SUCCEEDED)
719                 goto failed_openfcp;
720
721         atomic_set_mask(ZFCP_STATUS_COMMON_OPEN, &act->adapter->status);
722         schedule_work(&act->adapter->scan_work);
723
724         return ZFCP_ERP_SUCCEEDED;
725
726  close_only:
727         atomic_clear_mask(ZFCP_STATUS_COMMON_OPEN,
728                           &act->adapter->status);
729
730  failed_openfcp:
731         /* close queues to ensure that buffers are not accessed by adapter */
732         zfcp_qdio_close(adapter);
733         zfcp_fsf_req_dismiss_all(adapter);
734         adapter->fsf_req_seq_no = 0;
735         /* all ports and units are closed */
736         zfcp_erp_modify_adapter_status(adapter, 24, NULL,
737                                        ZFCP_STATUS_COMMON_OPEN, ZFCP_CLEAR);
738  failed_qdio:
739         atomic_clear_mask(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
740                           ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
741                           &act->adapter->status);
742         return retval;
743 }
744
745 static int zfcp_erp_adapter_strategy(struct zfcp_erp_action *act)
746 {
747         int retval;
748
749         zfcp_erp_adapter_strategy_generic(act, 1); /* close */
750         if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
751                 return ZFCP_ERP_EXIT;
752
753         retval = zfcp_erp_adapter_strategy_generic(act, 0); /* open */
754
755         if (retval == ZFCP_ERP_FAILED)
756                 ssleep(8);
757
758         return retval;
759 }
760
761 static int zfcp_erp_port_forced_strategy_close(struct zfcp_erp_action *act)
762 {
763         int retval;
764
765         retval = zfcp_fsf_close_physical_port(act);
766         if (retval == -ENOMEM)
767                 return ZFCP_ERP_NOMEM;
768         act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
769         if (retval)
770                 return ZFCP_ERP_FAILED;
771
772         return ZFCP_ERP_CONTINUES;
773 }
774
775 static void zfcp_erp_port_strategy_clearstati(struct zfcp_port *port)
776 {
777         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
778                           ZFCP_STATUS_PORT_PHYS_CLOSING |
779                           ZFCP_STATUS_PORT_INVALID_WWPN,
780                           &port->status);
781 }
782
783 static int zfcp_erp_port_forced_strategy(struct zfcp_erp_action *erp_action)
784 {
785         struct zfcp_port *port = erp_action->port;
786         int status = atomic_read(&port->status);
787
788         switch (erp_action->step) {
789         case ZFCP_ERP_STEP_UNINITIALIZED:
790                 zfcp_erp_port_strategy_clearstati(port);
791                 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
792                     (status & ZFCP_STATUS_COMMON_OPEN))
793                         return zfcp_erp_port_forced_strategy_close(erp_action);
794                 else
795                         return ZFCP_ERP_FAILED;
796
797         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
798                 if (status & ZFCP_STATUS_PORT_PHYS_OPEN)
799                         return ZFCP_ERP_SUCCEEDED;
800         }
801         return ZFCP_ERP_FAILED;
802 }
803
804 static int zfcp_erp_port_strategy_close(struct zfcp_erp_action *erp_action)
805 {
806         int retval;
807
808         retval = zfcp_fsf_close_port(erp_action);
809         if (retval == -ENOMEM)
810                 return ZFCP_ERP_NOMEM;
811         erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
812         if (retval)
813                 return ZFCP_ERP_FAILED;
814         return ZFCP_ERP_CONTINUES;
815 }
816
817 static int zfcp_erp_port_strategy_open_port(struct zfcp_erp_action *erp_action)
818 {
819         int retval;
820
821         retval = zfcp_fsf_open_port(erp_action);
822         if (retval == -ENOMEM)
823                 return ZFCP_ERP_NOMEM;
824         erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
825         if (retval)
826                 return ZFCP_ERP_FAILED;
827         return ZFCP_ERP_CONTINUES;
828 }
829
830 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
831 {
832         struct zfcp_adapter *adapter = act->adapter;
833         struct zfcp_port *port = act->port;
834
835         if (port->wwpn != adapter->peer_wwpn) {
836                 zfcp_erp_port_failed(port, 25, NULL);
837                 return ZFCP_ERP_FAILED;
838         }
839         port->d_id = adapter->peer_d_id;
840         atomic_set_mask(ZFCP_STATUS_PORT_DID_DID, &port->status);
841         return zfcp_erp_port_strategy_open_port(act);
842 }
843
844 void zfcp_erp_port_strategy_open_lookup(struct work_struct *work)
845 {
846         int retval;
847         struct zfcp_port *port = container_of(work, struct zfcp_port,
848                                               gid_pn_work);
849
850         retval = zfcp_fc_ns_gid_pn(&port->erp_action);
851         if (retval == -ENOMEM)
852                 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_NOMEM);
853         port->erp_action.step = ZFCP_ERP_STEP_NAMESERVER_LOOKUP;
854         if (retval)
855                 zfcp_erp_notify(&port->erp_action, ZFCP_ERP_FAILED);
856
857 }
858
859 static int zfcp_erp_port_strategy_open_common(struct zfcp_erp_action *act)
860 {
861         struct zfcp_adapter *adapter = act->adapter;
862         struct zfcp_port *port = act->port;
863         int p_status = atomic_read(&port->status);
864
865         switch (act->step) {
866         case ZFCP_ERP_STEP_UNINITIALIZED:
867         case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
868         case ZFCP_ERP_STEP_PORT_CLOSING:
869                 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
870                         return zfcp_erp_open_ptp_port(act);
871                 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
872                         schedule_work(&port->gid_pn_work);
873                         return ZFCP_ERP_CONTINUES;
874                 }
875         case ZFCP_ERP_STEP_NAMESERVER_LOOKUP:
876                 if (!(p_status & ZFCP_STATUS_PORT_DID_DID)) {
877                         if (p_status & (ZFCP_STATUS_PORT_INVALID_WWPN)) {
878                                 zfcp_erp_port_failed(port, 26, NULL);
879                                 return ZFCP_ERP_EXIT;
880                         }
881                         return ZFCP_ERP_FAILED;
882                 }
883                 return zfcp_erp_port_strategy_open_port(act);
884
885         case ZFCP_ERP_STEP_PORT_OPENING:
886                 /* D_ID might have changed during open */
887                 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
888                         if (p_status & ZFCP_STATUS_PORT_DID_DID)
889                                 return ZFCP_ERP_SUCCEEDED;
890                         else {
891                                 act->step = ZFCP_ERP_STEP_PORT_CLOSING;
892                                 return ZFCP_ERP_CONTINUES;
893                         }
894                 /* fall through otherwise */
895                 }
896         }
897         return ZFCP_ERP_FAILED;
898 }
899
900 static int zfcp_erp_port_strategy(struct zfcp_erp_action *erp_action)
901 {
902         struct zfcp_port *port = erp_action->port;
903
904         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC)
905                 goto close_init_done;
906
907         switch (erp_action->step) {
908         case ZFCP_ERP_STEP_UNINITIALIZED:
909                 zfcp_erp_port_strategy_clearstati(port);
910                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
911                         return zfcp_erp_port_strategy_close(erp_action);
912                 break;
913
914         case ZFCP_ERP_STEP_PORT_CLOSING:
915                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_OPEN)
916                         return ZFCP_ERP_FAILED;
917                 break;
918         }
919
920 close_init_done:
921         if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
922                 return ZFCP_ERP_EXIT;
923
924         return zfcp_erp_port_strategy_open_common(erp_action);
925 }
926
927 static void zfcp_erp_unit_strategy_clearstati(struct zfcp_unit *unit)
928 {
929         atomic_clear_mask(ZFCP_STATUS_COMMON_ACCESS_DENIED |
930                           ZFCP_STATUS_UNIT_SHARED |
931                           ZFCP_STATUS_UNIT_READONLY,
932                           &unit->status);
933 }
934
935 static int zfcp_erp_unit_strategy_close(struct zfcp_erp_action *erp_action)
936 {
937         int retval = zfcp_fsf_close_unit(erp_action);
938         if (retval == -ENOMEM)
939                 return ZFCP_ERP_NOMEM;
940         erp_action->step = ZFCP_ERP_STEP_UNIT_CLOSING;
941         if (retval)
942                 return ZFCP_ERP_FAILED;
943         return ZFCP_ERP_CONTINUES;
944 }
945
946 static int zfcp_erp_unit_strategy_open(struct zfcp_erp_action *erp_action)
947 {
948         int retval = zfcp_fsf_open_unit(erp_action);
949         if (retval == -ENOMEM)
950                 return ZFCP_ERP_NOMEM;
951         erp_action->step = ZFCP_ERP_STEP_UNIT_OPENING;
952         if (retval)
953                 return  ZFCP_ERP_FAILED;
954         return ZFCP_ERP_CONTINUES;
955 }
956
957 static int zfcp_erp_unit_strategy(struct zfcp_erp_action *erp_action)
958 {
959         struct zfcp_unit *unit = erp_action->unit;
960
961         switch (erp_action->step) {
962         case ZFCP_ERP_STEP_UNINITIALIZED:
963                 zfcp_erp_unit_strategy_clearstati(unit);
964                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
965                         return zfcp_erp_unit_strategy_close(erp_action);
966                 /* already closed, fall through */
967         case ZFCP_ERP_STEP_UNIT_CLOSING:
968                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
969                         return ZFCP_ERP_FAILED;
970                 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
971                         return ZFCP_ERP_EXIT;
972                 return zfcp_erp_unit_strategy_open(erp_action);
973
974         case ZFCP_ERP_STEP_UNIT_OPENING:
975                 if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_OPEN)
976                         return ZFCP_ERP_SUCCEEDED;
977         }
978         return ZFCP_ERP_FAILED;
979 }
980
981 static int zfcp_erp_strategy_check_unit(struct zfcp_unit *unit, int result)
982 {
983         switch (result) {
984         case ZFCP_ERP_SUCCEEDED :
985                 atomic_set(&unit->erp_counter, 0);
986                 zfcp_erp_unit_unblock(unit);
987                 break;
988         case ZFCP_ERP_FAILED :
989                 atomic_inc(&unit->erp_counter);
990                 if (atomic_read(&unit->erp_counter) > ZFCP_MAX_ERPS) {
991                         dev_err(&unit->port->adapter->ccw_device->dev,
992                                 "ERP failed for unit 0x%016Lx on "
993                                 "port 0x%016Lx\n",
994                                 (unsigned long long)unit->fcp_lun,
995                                 (unsigned long long)unit->port->wwpn);
996                         zfcp_erp_unit_failed(unit, 21, NULL);
997                 }
998                 break;
999         }
1000
1001         if (atomic_read(&unit->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1002                 zfcp_erp_unit_block(unit, 0);
1003                 result = ZFCP_ERP_EXIT;
1004         }
1005         return result;
1006 }
1007
1008 static int zfcp_erp_strategy_check_port(struct zfcp_port *port, int result)
1009 {
1010         switch (result) {
1011         case ZFCP_ERP_SUCCEEDED :
1012                 atomic_set(&port->erp_counter, 0);
1013                 zfcp_erp_port_unblock(port);
1014                 break;
1015
1016         case ZFCP_ERP_FAILED :
1017                 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1018                         zfcp_erp_port_block(port, 0);
1019                         result = ZFCP_ERP_EXIT;
1020                 }
1021                 atomic_inc(&port->erp_counter);
1022                 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1023                         dev_err(&port->adapter->ccw_device->dev,
1024                                 "ERP failed for remote port 0x%016Lx\n",
1025                                 (unsigned long long)port->wwpn);
1026                         zfcp_erp_port_failed(port, 22, NULL);
1027                 }
1028                 break;
1029         }
1030
1031         if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1032                 zfcp_erp_port_block(port, 0);
1033                 result = ZFCP_ERP_EXIT;
1034         }
1035         return result;
1036 }
1037
1038 static int zfcp_erp_strategy_check_adapter(struct zfcp_adapter *adapter,
1039                                            int result)
1040 {
1041         switch (result) {
1042         case ZFCP_ERP_SUCCEEDED :
1043                 atomic_set(&adapter->erp_counter, 0);
1044                 zfcp_erp_adapter_unblock(adapter);
1045                 break;
1046
1047         case ZFCP_ERP_FAILED :
1048                 atomic_inc(&adapter->erp_counter);
1049                 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1050                         dev_err(&adapter->ccw_device->dev,
1051                                 "ERP cannot recover an error "
1052                                 "on the FCP device\n");
1053                         zfcp_erp_adapter_failed(adapter, 23, NULL);
1054                 }
1055                 break;
1056         }
1057
1058         if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1059                 zfcp_erp_adapter_block(adapter, 0);
1060                 result = ZFCP_ERP_EXIT;
1061         }
1062         return result;
1063 }
1064
1065 static int zfcp_erp_strategy_check_target(struct zfcp_erp_action *erp_action,
1066                                           int result)
1067 {
1068         struct zfcp_adapter *adapter = erp_action->adapter;
1069         struct zfcp_port *port = erp_action->port;
1070         struct zfcp_unit *unit = erp_action->unit;
1071
1072         switch (erp_action->action) {
1073
1074         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1075                 result = zfcp_erp_strategy_check_unit(unit, result);
1076                 break;
1077
1078         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1079         case ZFCP_ERP_ACTION_REOPEN_PORT:
1080                 result = zfcp_erp_strategy_check_port(port, result);
1081                 break;
1082
1083         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1084                 result = zfcp_erp_strategy_check_adapter(adapter, result);
1085                 break;
1086         }
1087         return result;
1088 }
1089
1090 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1091 {
1092         int status = atomic_read(target_status);
1093
1094         if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1095             (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1096                 return 1; /* take it online */
1097
1098         if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1099             !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1100                 return 1; /* take it offline */
1101
1102         return 0;
1103 }
1104
1105 static int zfcp_erp_strategy_statechange(struct zfcp_erp_action *act, int ret)
1106 {
1107         int action = act->action;
1108         struct zfcp_adapter *adapter = act->adapter;
1109         struct zfcp_port *port = act->port;
1110         struct zfcp_unit *unit = act->unit;
1111         u32 erp_status = act->status;
1112
1113         switch (action) {
1114         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1115                 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1116                         _zfcp_erp_adapter_reopen(adapter,
1117                                                  ZFCP_STATUS_COMMON_ERP_FAILED,
1118                                                  67, NULL);
1119                         return ZFCP_ERP_EXIT;
1120                 }
1121                 break;
1122
1123         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1124         case ZFCP_ERP_ACTION_REOPEN_PORT:
1125                 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1126                         _zfcp_erp_port_reopen(port,
1127                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1128                                               68, NULL);
1129                         return ZFCP_ERP_EXIT;
1130                 }
1131                 break;
1132
1133         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1134                 if (zfcp_erp_strat_change_det(&unit->status, erp_status)) {
1135                         _zfcp_erp_unit_reopen(unit,
1136                                               ZFCP_STATUS_COMMON_ERP_FAILED,
1137                                               69, NULL);
1138                         return ZFCP_ERP_EXIT;
1139                 }
1140                 break;
1141         }
1142         return ret;
1143 }
1144
1145 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1146 {
1147         struct zfcp_adapter *adapter = erp_action->adapter;
1148
1149         adapter->erp_total_count--;
1150         if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1151                 adapter->erp_low_mem_count--;
1152                 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1153         }
1154
1155         list_del(&erp_action->list);
1156         zfcp_rec_dbf_event_action(144, erp_action);
1157
1158         switch (erp_action->action) {
1159         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1160                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1161                                   &erp_action->unit->status);
1162                 break;
1163
1164         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1165         case ZFCP_ERP_ACTION_REOPEN_PORT:
1166                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1167                                   &erp_action->port->status);
1168                 break;
1169
1170         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1171                 atomic_clear_mask(ZFCP_STATUS_COMMON_ERP_INUSE,
1172                                   &erp_action->adapter->status);
1173                 break;
1174         }
1175 }
1176
1177 struct zfcp_erp_add_work {
1178         struct zfcp_unit  *unit;
1179         struct work_struct work;
1180 };
1181
1182 static void zfcp_erp_scsi_scan(struct work_struct *work)
1183 {
1184         struct zfcp_erp_add_work *p =
1185                 container_of(work, struct zfcp_erp_add_work, work);
1186         struct zfcp_unit *unit = p->unit;
1187         struct fc_rport *rport = unit->port->rport;
1188         scsi_scan_target(&rport->dev, 0, rport->scsi_target_id,
1189                          unit->scsi_lun, 0);
1190         atomic_clear_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1191         zfcp_unit_put(unit);
1192         kfree(p);
1193 }
1194
1195 static void zfcp_erp_schedule_work(struct zfcp_unit *unit)
1196 {
1197         struct zfcp_erp_add_work *p;
1198
1199         p = kzalloc(sizeof(*p), GFP_KERNEL);
1200         if (!p) {
1201                 dev_err(&unit->port->adapter->ccw_device->dev,
1202                         "Registering unit 0x%016Lx on port 0x%016Lx failed\n",
1203                         (unsigned long long)unit->fcp_lun,
1204                         (unsigned long long)unit->port->wwpn);
1205                 return;
1206         }
1207
1208         zfcp_unit_get(unit);
1209         atomic_set_mask(ZFCP_STATUS_UNIT_SCSI_WORK_PENDING, &unit->status);
1210         INIT_WORK(&p->work, zfcp_erp_scsi_scan);
1211         p->unit = unit;
1212         schedule_work(&p->work);
1213 }
1214
1215 static void zfcp_erp_rport_register(struct zfcp_port *port)
1216 {
1217         struct fc_rport_identifiers ids;
1218         ids.node_name = port->wwnn;
1219         ids.port_name = port->wwpn;
1220         ids.port_id = port->d_id;
1221         ids.roles = FC_RPORT_ROLE_FCP_TARGET;
1222         port->rport = fc_remote_port_add(port->adapter->scsi_host, 0, &ids);
1223         if (!port->rport) {
1224                 dev_err(&port->adapter->ccw_device->dev,
1225                         "Registering port 0x%016Lx failed\n",
1226                         (unsigned long long)port->wwpn);
1227                 return;
1228         }
1229
1230         scsi_target_unblock(&port->rport->dev);
1231         port->rport->maxframe_size = port->maxframe_size;
1232         port->rport->supported_classes = port->supported_classes;
1233 }
1234
1235 static void zfcp_erp_rports_del(struct zfcp_adapter *adapter)
1236 {
1237         struct zfcp_port *port;
1238         list_for_each_entry(port, &adapter->port_list_head, list) {
1239                 fc_remote_port_delete(port->rport);
1240                 port->rport = NULL;
1241         }
1242 }
1243
1244 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act, int result)
1245 {
1246         struct zfcp_adapter *adapter = act->adapter;
1247         struct zfcp_port *port = act->port;
1248         struct zfcp_unit *unit = act->unit;
1249
1250         switch (act->action) {
1251         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1252                 if ((result == ZFCP_ERP_SUCCEEDED) &&
1253                     !unit->device && port->rport) {
1254                         atomic_set_mask(ZFCP_STATUS_UNIT_REGISTERED,
1255                                         &unit->status);
1256                         if (!(atomic_read(&unit->status) &
1257                               ZFCP_STATUS_UNIT_SCSI_WORK_PENDING))
1258                                 zfcp_erp_schedule_work(unit);
1259                 }
1260                 zfcp_unit_put(unit);
1261                 break;
1262
1263         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1264         case ZFCP_ERP_ACTION_REOPEN_PORT:
1265                 if (atomic_read(&port->status) & ZFCP_STATUS_PORT_NO_WWPN) {
1266                         zfcp_port_put(port);
1267                         return;
1268                 }
1269                 if ((result == ZFCP_ERP_SUCCEEDED) && !port->rport)
1270                         zfcp_erp_rport_register(port);
1271                 if ((result != ZFCP_ERP_SUCCEEDED) && port->rport) {
1272                         fc_remote_port_delete(port->rport);
1273                         port->rport = NULL;
1274                 }
1275                 zfcp_port_put(port);
1276                 break;
1277
1278         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1279                 if (result != ZFCP_ERP_SUCCEEDED)
1280                         zfcp_erp_rports_del(adapter);
1281                 zfcp_adapter_put(adapter);
1282                 break;
1283         }
1284 }
1285
1286 static int zfcp_erp_strategy_do_action(struct zfcp_erp_action *erp_action)
1287 {
1288         switch (erp_action->action) {
1289         case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1290                 return zfcp_erp_adapter_strategy(erp_action);
1291         case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1292                 return zfcp_erp_port_forced_strategy(erp_action);
1293         case ZFCP_ERP_ACTION_REOPEN_PORT:
1294                 return zfcp_erp_port_strategy(erp_action);
1295         case ZFCP_ERP_ACTION_REOPEN_UNIT:
1296                 return zfcp_erp_unit_strategy(erp_action);
1297         }
1298         return ZFCP_ERP_FAILED;
1299 }
1300
1301 static int zfcp_erp_strategy(struct zfcp_erp_action *erp_action)
1302 {
1303         int retval;
1304         struct zfcp_adapter *adapter = erp_action->adapter;
1305         unsigned long flags;
1306
1307         read_lock_irqsave(&zfcp_data.config_lock, flags);
1308         write_lock(&adapter->erp_lock);
1309
1310         zfcp_erp_strategy_check_fsfreq(erp_action);
1311
1312         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1313                 zfcp_erp_action_dequeue(erp_action);
1314                 retval = ZFCP_ERP_DISMISSED;
1315                 goto unlock;
1316         }
1317
1318         zfcp_erp_action_to_running(erp_action);
1319
1320         /* no lock to allow for blocking operations */
1321         write_unlock(&adapter->erp_lock);
1322         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1323         retval = zfcp_erp_strategy_do_action(erp_action);
1324         read_lock_irqsave(&zfcp_data.config_lock, flags);
1325         write_lock(&adapter->erp_lock);
1326
1327         if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1328                 retval = ZFCP_ERP_CONTINUES;
1329
1330         switch (retval) {
1331         case ZFCP_ERP_NOMEM:
1332                 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1333                         ++adapter->erp_low_mem_count;
1334                         erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1335                 }
1336                 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1337                         _zfcp_erp_adapter_reopen(adapter, 0, 66, NULL);
1338                 else {
1339                         zfcp_erp_strategy_memwait(erp_action);
1340                         retval = ZFCP_ERP_CONTINUES;
1341                 }
1342                 goto unlock;
1343
1344         case ZFCP_ERP_CONTINUES:
1345                 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1346                         --adapter->erp_low_mem_count;
1347                         erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1348                 }
1349                 goto unlock;
1350         }
1351
1352         retval = zfcp_erp_strategy_check_target(erp_action, retval);
1353         zfcp_erp_action_dequeue(erp_action);
1354         retval = zfcp_erp_strategy_statechange(erp_action, retval);
1355         if (retval == ZFCP_ERP_EXIT)
1356                 goto unlock;
1357         zfcp_erp_strategy_followup_actions(erp_action);
1358
1359  unlock:
1360         write_unlock(&adapter->erp_lock);
1361         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1362
1363         if (retval != ZFCP_ERP_CONTINUES)
1364                 zfcp_erp_action_cleanup(erp_action, retval);
1365
1366         return retval;
1367 }
1368
1369 static int zfcp_erp_thread(void *data)
1370 {
1371         struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1372         struct list_head *next;
1373         struct zfcp_erp_action *act;
1374         unsigned long flags;
1375
1376         daemonize("zfcperp%s", adapter->ccw_device->dev.bus_id);
1377         /* Block all signals */
1378         siginitsetinv(&current->blocked, 0);
1379         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1380         wake_up(&adapter->erp_thread_wqh);
1381
1382         while (!(atomic_read(&adapter->status) &
1383                  ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL)) {
1384                 write_lock_irqsave(&adapter->erp_lock, flags);
1385                 next = adapter->erp_ready_head.next;
1386                 write_unlock_irqrestore(&adapter->erp_lock, flags);
1387
1388                 if (next != &adapter->erp_ready_head) {
1389                         act = list_entry(next, struct zfcp_erp_action, list);
1390
1391                         /* there is more to come after dismission, no notify */
1392                         if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1393                                 zfcp_erp_wakeup(adapter);
1394                 }
1395
1396                 zfcp_rec_dbf_event_thread(4, adapter);
1397                 down_interruptible(&adapter->erp_ready_sem);
1398                 zfcp_rec_dbf_event_thread(5, adapter);
1399         }
1400
1401         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1402         wake_up(&adapter->erp_thread_wqh);
1403
1404         return 0;
1405 }
1406
1407 /**
1408  * zfcp_erp_thread_setup - Start ERP thread for adapter
1409  * @adapter: Adapter to start the ERP thread for
1410  *
1411  * Returns 0 on success or error code from kernel_thread()
1412  */
1413 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1414 {
1415         int retval;
1416
1417         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_UP, &adapter->status);
1418         retval = kernel_thread(zfcp_erp_thread, adapter, SIGCHLD);
1419         if (retval < 0) {
1420                 dev_err(&adapter->ccw_device->dev,
1421                         "Creating an ERP thread for the FCP device failed.\n");
1422                 return retval;
1423         }
1424         wait_event(adapter->erp_thread_wqh,
1425                    atomic_read(&adapter->status) &
1426                         ZFCP_STATUS_ADAPTER_ERP_THREAD_UP);
1427         return 0;
1428 }
1429
1430 /**
1431  * zfcp_erp_thread_kill - Stop ERP thread.
1432  * @adapter: Adapter where the ERP thread should be stopped.
1433  *
1434  * The caller of this routine ensures that the specified adapter has
1435  * been shut down and that this operation has been completed. Thus,
1436  * there are no pending erp_actions which would need to be handled
1437  * here.
1438  */
1439 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1440 {
1441         atomic_set_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL, &adapter->status);
1442         up(&adapter->erp_ready_sem);
1443         zfcp_rec_dbf_event_thread_lock(2, adapter);
1444
1445         wait_event(adapter->erp_thread_wqh,
1446                    !(atomic_read(&adapter->status) &
1447                                 ZFCP_STATUS_ADAPTER_ERP_THREAD_UP));
1448
1449         atomic_clear_mask(ZFCP_STATUS_ADAPTER_ERP_THREAD_KILL,
1450                           &adapter->status);
1451 }
1452
1453 /**
1454  * zfcp_erp_adapter_failed - Set adapter status to failed.
1455  * @adapter: Failed adapter.
1456  * @id: Event id for debug trace.
1457  * @ref: Reference for debug trace.
1458  */
1459 void zfcp_erp_adapter_failed(struct zfcp_adapter *adapter, u8 id, void *ref)
1460 {
1461         zfcp_erp_modify_adapter_status(adapter, id, ref,
1462                                        ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1463 }
1464
1465 /**
1466  * zfcp_erp_port_failed - Set port status to failed.
1467  * @port: Failed port.
1468  * @id: Event id for debug trace.
1469  * @ref: Reference for debug trace.
1470  */
1471 void zfcp_erp_port_failed(struct zfcp_port *port, u8 id, void *ref)
1472 {
1473         zfcp_erp_modify_port_status(port, id, ref,
1474                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1475 }
1476
1477 /**
1478  * zfcp_erp_unit_failed - Set unit status to failed.
1479  * @unit: Failed unit.
1480  * @id: Event id for debug trace.
1481  * @ref: Reference for debug trace.
1482  */
1483 void zfcp_erp_unit_failed(struct zfcp_unit *unit, u8 id, void *ref)
1484 {
1485         zfcp_erp_modify_unit_status(unit, id, ref,
1486                                     ZFCP_STATUS_COMMON_ERP_FAILED, ZFCP_SET);
1487 }
1488
1489 /**
1490  * zfcp_erp_wait - wait for completion of error recovery on an adapter
1491  * @adapter: adapter for which to wait for completion of its error recovery
1492  */
1493 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1494 {
1495         wait_event(adapter->erp_done_wqh,
1496                    !(atomic_read(&adapter->status) &
1497                         ZFCP_STATUS_ADAPTER_ERP_PENDING));
1498 }
1499
1500 /**
1501  * zfcp_erp_modify_adapter_status - change adapter status bits
1502  * @adapter: adapter to change the status
1503  * @id: id for the debug trace
1504  * @ref: reference for the debug trace
1505  * @mask: status bits to change
1506  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1507  *
1508  * Changes in common status bits are propagated to attached ports and units.
1509  */
1510 void zfcp_erp_modify_adapter_status(struct zfcp_adapter *adapter, u8 id,
1511                                     void *ref, u32 mask, int set_or_clear)
1512 {
1513         struct zfcp_port *port;
1514         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1515
1516         if (set_or_clear == ZFCP_SET) {
1517                 if (status_change_set(mask, &adapter->status))
1518                         zfcp_rec_dbf_event_adapter(id, ref, adapter);
1519                 atomic_set_mask(mask, &adapter->status);
1520         } else {
1521                 if (status_change_clear(mask, &adapter->status))
1522                         zfcp_rec_dbf_event_adapter(id, ref, adapter);
1523                 atomic_clear_mask(mask, &adapter->status);
1524                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1525                         atomic_set(&adapter->erp_counter, 0);
1526         }
1527
1528         if (common_mask)
1529                 list_for_each_entry(port, &adapter->port_list_head, list)
1530                         zfcp_erp_modify_port_status(port, id, ref, common_mask,
1531                                                     set_or_clear);
1532 }
1533
1534 /**
1535  * zfcp_erp_modify_port_status - change port status bits
1536  * @port: port to change the status bits
1537  * @id: id for the debug trace
1538  * @ref: reference for the debug trace
1539  * @mask: status bits to change
1540  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1541  *
1542  * Changes in common status bits are propagated to attached units.
1543  */
1544 void zfcp_erp_modify_port_status(struct zfcp_port *port, u8 id, void *ref,
1545                                  u32 mask, int set_or_clear)
1546 {
1547         struct zfcp_unit *unit;
1548         u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1549
1550         if (set_or_clear == ZFCP_SET) {
1551                 if (status_change_set(mask, &port->status))
1552                         zfcp_rec_dbf_event_port(id, ref, port);
1553                 atomic_set_mask(mask, &port->status);
1554         } else {
1555                 if (status_change_clear(mask, &port->status))
1556                         zfcp_rec_dbf_event_port(id, ref, port);
1557                 atomic_clear_mask(mask, &port->status);
1558                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1559                         atomic_set(&port->erp_counter, 0);
1560         }
1561
1562         if (common_mask)
1563                 list_for_each_entry(unit, &port->unit_list_head, list)
1564                         zfcp_erp_modify_unit_status(unit, id, ref, common_mask,
1565                                                     set_or_clear);
1566 }
1567
1568 /**
1569  * zfcp_erp_modify_unit_status - change unit status bits
1570  * @unit: unit to change the status bits
1571  * @id: id for the debug trace
1572  * @ref: reference for the debug trace
1573  * @mask: status bits to change
1574  * @set_or_clear: ZFCP_SET or ZFCP_CLEAR
1575  */
1576 void zfcp_erp_modify_unit_status(struct zfcp_unit *unit, u8 id, void *ref,
1577                                  u32 mask, int set_or_clear)
1578 {
1579         if (set_or_clear == ZFCP_SET) {
1580                 if (status_change_set(mask, &unit->status))
1581                         zfcp_rec_dbf_event_unit(id, ref, unit);
1582                 atomic_set_mask(mask, &unit->status);
1583         } else {
1584                 if (status_change_clear(mask, &unit->status))
1585                         zfcp_rec_dbf_event_unit(id, ref, unit);
1586                 atomic_clear_mask(mask, &unit->status);
1587                 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED) {
1588                         atomic_set(&unit->erp_counter, 0);
1589                 }
1590         }
1591 }
1592
1593 /**
1594  * zfcp_erp_port_boxed - Mark port as "boxed" and start ERP
1595  * @port: The "boxed" port.
1596  * @id: The debug trace id.
1597  * @id: Reference for the debug trace.
1598  */
1599 void zfcp_erp_port_boxed(struct zfcp_port *port, u8 id, void *ref)
1600 {
1601         unsigned long flags;
1602
1603         read_lock_irqsave(&zfcp_data.config_lock, flags);
1604         zfcp_erp_modify_port_status(port, id, ref,
1605                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1606         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1607         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1608 }
1609
1610 /**
1611  * zfcp_erp_unit_boxed - Mark unit as "boxed" and start ERP
1612  * @port: The "boxed" unit.
1613  * @id: The debug trace id.
1614  * @id: Reference for the debug trace.
1615  */
1616 void zfcp_erp_unit_boxed(struct zfcp_unit *unit, u8 id, void *ref)
1617 {
1618         zfcp_erp_modify_unit_status(unit, id, ref,
1619                                     ZFCP_STATUS_COMMON_ACCESS_BOXED, ZFCP_SET);
1620         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1621 }
1622
1623 /**
1624  * zfcp_erp_port_access_denied - Adapter denied access to port.
1625  * @port: port where access has been denied
1626  * @id: id for debug trace
1627  * @ref: reference for debug trace
1628  *
1629  * Since the adapter has denied access, stop using the port and the
1630  * attached units.
1631  */
1632 void zfcp_erp_port_access_denied(struct zfcp_port *port, u8 id, void *ref)
1633 {
1634         unsigned long flags;
1635
1636         read_lock_irqsave(&zfcp_data.config_lock, flags);
1637         zfcp_erp_modify_port_status(port, id, ref,
1638                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1639                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1640         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1641 }
1642
1643 /**
1644  * zfcp_erp_unit_access_denied - Adapter denied access to unit.
1645  * @unit: unit where access has been denied
1646  * @id: id for debug trace
1647  * @ref: reference for debug trace
1648  *
1649  * Since the adapter has denied access, stop using the unit.
1650  */
1651 void zfcp_erp_unit_access_denied(struct zfcp_unit *unit, u8 id, void *ref)
1652 {
1653         zfcp_erp_modify_unit_status(unit, id, ref,
1654                                     ZFCP_STATUS_COMMON_ERP_FAILED |
1655                                     ZFCP_STATUS_COMMON_ACCESS_DENIED, ZFCP_SET);
1656 }
1657
1658 static void zfcp_erp_unit_access_changed(struct zfcp_unit *unit, u8 id,
1659                                          void *ref)
1660 {
1661         int status = atomic_read(&unit->status);
1662         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1663                         ZFCP_STATUS_COMMON_ACCESS_BOXED)))
1664                 return;
1665
1666         zfcp_erp_unit_reopen(unit, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1667 }
1668
1669 static void zfcp_erp_port_access_changed(struct zfcp_port *port, u8 id,
1670                                          void *ref)
1671 {
1672         struct zfcp_unit *unit;
1673         int status = atomic_read(&port->status);
1674
1675         if (!(status & (ZFCP_STATUS_COMMON_ACCESS_DENIED |
1676                         ZFCP_STATUS_COMMON_ACCESS_BOXED))) {
1677                 list_for_each_entry(unit, &port->unit_list_head, list)
1678                                     zfcp_erp_unit_access_changed(unit, id, ref);
1679                 return;
1680         }
1681
1682         zfcp_erp_port_reopen(port, ZFCP_STATUS_COMMON_ERP_FAILED, id, ref);
1683 }
1684
1685 /**
1686  * zfcp_erp_adapter_access_changed - Process change in adapter ACT
1687  * @adapter: Adapter where the Access Control Table (ACT) changed
1688  * @id: Id for debug trace
1689  * @ref: Reference for debug trace
1690  */
1691 void zfcp_erp_adapter_access_changed(struct zfcp_adapter *adapter, u8 id,
1692                                      void *ref)
1693 {
1694         struct zfcp_port *port;
1695         unsigned long flags;
1696
1697         if (adapter->connection_features & FSF_FEATURE_NPIV_MODE)
1698                 return;
1699
1700         read_lock_irqsave(&zfcp_data.config_lock, flags);
1701         list_for_each_entry(port, &adapter->port_list_head, list)
1702                 zfcp_erp_port_access_changed(port, id, ref);
1703         read_unlock_irqrestore(&zfcp_data.config_lock, flags);
1704 }