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