1 // SPDX-License-Identifier: GPL-2.0
5 * Error Recovery Procedures (ERP).
7 * Copyright IBM Corp. 2002, 2020
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/kthread.h>
14 #include <linux/bug.h>
16 #include "zfcp_reqlist.h"
17 #include "zfcp_diag.h"
19 #define ZFCP_MAX_ERPS 3
21 enum zfcp_erp_act_flags {
22 ZFCP_STATUS_ERP_TIMEDOUT = 0x10000000,
23 ZFCP_STATUS_ERP_CLOSE_ONLY = 0x01000000,
24 ZFCP_STATUS_ERP_DISMISSED = 0x00200000,
25 ZFCP_STATUS_ERP_LOWMEM = 0x00400000,
26 ZFCP_STATUS_ERP_NO_REF = 0x00800000,
30 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
31 * Used to indicate that an ERP action could not be set up despite a detected
32 * need for some recovery.
34 #define ZFCP_ERP_ACTION_NONE 0xc0
36 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
37 * Used to indicate that ERP not needed because the object has
38 * ZFCP_STATUS_COMMON_ERP_FAILED.
40 #define ZFCP_ERP_ACTION_FAILED 0xe0
42 enum zfcp_erp_act_result {
43 ZFCP_ERP_SUCCEEDED = 0,
45 ZFCP_ERP_CONTINUES = 2,
47 ZFCP_ERP_DISMISSED = 4,
51 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
53 zfcp_erp_clear_adapter_status(adapter,
54 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
57 static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)
59 struct zfcp_erp_action *curr_act;
61 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
67 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
69 struct zfcp_adapter *adapter = act->adapter;
71 list_move(&act->list, &adapter->erp_ready_head);
72 zfcp_dbf_rec_run("erardy1", act);
73 wake_up(&adapter->erp_ready_wq);
74 zfcp_dbf_rec_run("erardy2", act);
77 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
79 act->status |= ZFCP_STATUS_ERP_DISMISSED;
80 if (zfcp_erp_action_is_running(act))
81 zfcp_erp_action_ready(act);
84 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
86 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
88 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
89 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
92 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
94 struct scsi_device *sdev;
96 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
97 zfcp_erp_action_dismiss(&port->erp_action);
99 spin_lock(port->adapter->scsi_host->host_lock);
100 __shost_for_each_device(sdev, port->adapter->scsi_host)
101 if (sdev_to_zfcp(sdev)->port == port)
102 zfcp_erp_action_dismiss_lun(sdev);
103 spin_unlock(port->adapter->scsi_host->host_lock);
107 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
109 struct zfcp_port *port;
111 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
112 zfcp_erp_action_dismiss(&adapter->erp_action);
114 read_lock(&adapter->port_list_lock);
115 list_for_each_entry(port, &adapter->port_list, list)
116 zfcp_erp_action_dismiss_port(port);
117 read_unlock(&adapter->port_list_lock);
121 static enum zfcp_erp_act_type zfcp_erp_handle_failed(
122 enum zfcp_erp_act_type want, struct zfcp_adapter *adapter,
123 struct zfcp_port *port, struct scsi_device *sdev)
125 enum zfcp_erp_act_type need = want;
126 struct zfcp_scsi_dev *zsdev;
129 case ZFCP_ERP_ACTION_REOPEN_LUN:
130 zsdev = sdev_to_zfcp(sdev);
131 if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
134 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
135 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
138 case ZFCP_ERP_ACTION_REOPEN_PORT:
139 if (atomic_read(&port->status) &
140 ZFCP_STATUS_COMMON_ERP_FAILED) {
142 /* ensure propagation of failed status to new devices */
143 zfcp_erp_set_port_status(
144 port, ZFCP_STATUS_COMMON_ERP_FAILED);
147 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
148 if (atomic_read(&adapter->status) &
149 ZFCP_STATUS_COMMON_ERP_FAILED) {
151 /* ensure propagation of failed status to new devices */
152 zfcp_erp_set_adapter_status(
153 adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
161 static enum zfcp_erp_act_type zfcp_erp_required_act(enum zfcp_erp_act_type want,
162 struct zfcp_adapter *adapter,
163 struct zfcp_port *port,
164 struct scsi_device *sdev)
166 enum zfcp_erp_act_type need = want;
167 int l_status, p_status, a_status;
168 struct zfcp_scsi_dev *zfcp_sdev;
171 case ZFCP_ERP_ACTION_REOPEN_LUN:
172 zfcp_sdev = sdev_to_zfcp(sdev);
173 l_status = atomic_read(&zfcp_sdev->status);
174 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
176 p_status = atomic_read(&port->status);
177 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
178 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
180 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
181 need = ZFCP_ERP_ACTION_REOPEN_PORT;
183 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
184 p_status = atomic_read(&port->status);
185 if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
186 need = ZFCP_ERP_ACTION_REOPEN_PORT;
188 case ZFCP_ERP_ACTION_REOPEN_PORT:
189 p_status = atomic_read(&port->status);
190 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
192 a_status = atomic_read(&adapter->status);
193 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
194 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
196 if (p_status & ZFCP_STATUS_COMMON_NOESC)
198 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
199 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
201 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
202 a_status = atomic_read(&adapter->status);
203 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
205 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
206 !(a_status & ZFCP_STATUS_COMMON_OPEN))
207 return 0; /* shutdown requested for closed adapter */
213 static struct zfcp_erp_action *zfcp_erp_setup_act(enum zfcp_erp_act_type need,
215 struct zfcp_adapter *adapter,
216 struct zfcp_port *port,
217 struct scsi_device *sdev)
219 struct zfcp_erp_action *erp_action;
220 struct zfcp_scsi_dev *zfcp_sdev;
222 if (WARN_ON_ONCE(need != ZFCP_ERP_ACTION_REOPEN_LUN &&
223 need != ZFCP_ERP_ACTION_REOPEN_PORT &&
224 need != ZFCP_ERP_ACTION_REOPEN_PORT_FORCED &&
225 need != ZFCP_ERP_ACTION_REOPEN_ADAPTER))
229 case ZFCP_ERP_ACTION_REOPEN_LUN:
230 zfcp_sdev = sdev_to_zfcp(sdev);
231 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
232 if (scsi_device_get(sdev))
234 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
236 erp_action = &zfcp_sdev->erp_action;
237 WARN_ON_ONCE(erp_action->port != port);
238 WARN_ON_ONCE(erp_action->sdev != sdev);
239 if (!(atomic_read(&zfcp_sdev->status) &
240 ZFCP_STATUS_COMMON_RUNNING))
241 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
244 case ZFCP_ERP_ACTION_REOPEN_PORT:
245 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
246 if (!get_device(&port->dev))
248 zfcp_erp_action_dismiss_port(port);
249 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
250 erp_action = &port->erp_action;
251 WARN_ON_ONCE(erp_action->port != port);
252 WARN_ON_ONCE(erp_action->sdev != NULL);
253 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
254 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
257 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
258 kref_get(&adapter->ref);
259 zfcp_erp_action_dismiss_adapter(adapter);
260 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
261 erp_action = &adapter->erp_action;
262 WARN_ON_ONCE(erp_action->port != NULL);
263 WARN_ON_ONCE(erp_action->sdev != NULL);
264 if (!(atomic_read(&adapter->status) &
265 ZFCP_STATUS_COMMON_RUNNING))
266 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
270 WARN_ON_ONCE(erp_action->adapter != adapter);
271 memset(&erp_action->list, 0, sizeof(erp_action->list));
272 memset(&erp_action->timer, 0, sizeof(erp_action->timer));
273 erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
274 erp_action->fsf_req_id = 0;
275 erp_action->type = need;
276 erp_action->status = act_status;
281 static void zfcp_erp_action_enqueue(enum zfcp_erp_act_type want,
282 struct zfcp_adapter *adapter,
283 struct zfcp_port *port,
284 struct scsi_device *sdev,
285 char *dbftag, u32 act_status)
287 enum zfcp_erp_act_type need;
288 struct zfcp_erp_action *act;
290 need = zfcp_erp_handle_failed(want, adapter, port, sdev);
292 need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
296 if (!adapter->erp_thread) {
297 need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
301 need = zfcp_erp_required_act(want, adapter, port, sdev);
305 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
307 need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
310 atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
311 ++adapter->erp_total_count;
312 list_add_tail(&act->list, &adapter->erp_ready_head);
313 wake_up(&adapter->erp_ready_wq);
315 zfcp_dbf_rec_trig(dbftag, adapter, port, sdev, want, need);
318 void zfcp_erp_port_forced_no_port_dbf(char *dbftag,
319 struct zfcp_adapter *adapter,
320 u64 port_name, u32 port_id)
323 static /* don't waste stack */ struct zfcp_port tmpport;
325 write_lock_irqsave(&adapter->erp_lock, flags);
326 /* Stand-in zfcp port with fields just good enough for
327 * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
328 * Under lock because tmpport is static.
330 atomic_set(&tmpport.status, -1); /* unknown */
331 tmpport.wwpn = port_name;
332 tmpport.d_id = port_id;
333 zfcp_dbf_rec_trig(dbftag, adapter, &tmpport, NULL,
334 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
335 ZFCP_ERP_ACTION_NONE);
336 write_unlock_irqrestore(&adapter->erp_lock, flags);
339 static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
340 int clear_mask, char *dbftag)
342 zfcp_erp_adapter_block(adapter, clear_mask);
343 zfcp_scsi_schedule_rports_block(adapter);
345 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
346 adapter, NULL, NULL, dbftag, 0);
350 * zfcp_erp_adapter_reopen - Reopen adapter.
351 * @adapter: Adapter to reopen.
352 * @clear: Status flags to clear.
353 * @dbftag: Tag for debug trace event.
355 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
360 zfcp_erp_adapter_block(adapter, clear);
361 zfcp_scsi_schedule_rports_block(adapter);
363 write_lock_irqsave(&adapter->erp_lock, flags);
364 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
365 NULL, NULL, dbftag, 0);
366 write_unlock_irqrestore(&adapter->erp_lock, flags);
370 * zfcp_erp_adapter_shutdown - Shutdown adapter.
371 * @adapter: Adapter to shut down.
372 * @clear: Status flags to clear.
373 * @dbftag: Tag for debug trace event.
375 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
378 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
379 zfcp_erp_adapter_reopen(adapter, clear | flags, dbftag);
383 * zfcp_erp_port_shutdown - Shutdown port
384 * @port: Port to shut down.
385 * @clear: Status flags to clear.
386 * @dbftag: Tag for debug trace event.
388 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *dbftag)
390 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
391 zfcp_erp_port_reopen(port, clear | flags, dbftag);
394 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
396 zfcp_erp_clear_port_status(port,
397 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
400 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
403 zfcp_erp_port_block(port, clear);
404 zfcp_scsi_schedule_rport_block(port);
406 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
407 port->adapter, port, NULL, dbftag, 0);
411 * zfcp_erp_port_forced_reopen - Forced close of port and open again
412 * @port: Port to force close and to reopen.
413 * @clear: Status flags to clear.
414 * @dbftag: Tag for debug trace event.
416 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
420 struct zfcp_adapter *adapter = port->adapter;
422 write_lock_irqsave(&adapter->erp_lock, flags);
423 _zfcp_erp_port_forced_reopen(port, clear, dbftag);
424 write_unlock_irqrestore(&adapter->erp_lock, flags);
427 static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear,
430 zfcp_erp_port_block(port, clear);
431 zfcp_scsi_schedule_rport_block(port);
433 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
434 port->adapter, port, NULL, dbftag, 0);
438 * zfcp_erp_port_reopen - trigger remote port recovery
439 * @port: port to recover
440 * @clear: flags in port status to be cleared
441 * @dbftag: Tag for debug trace event.
443 void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *dbftag)
446 struct zfcp_adapter *adapter = port->adapter;
448 write_lock_irqsave(&adapter->erp_lock, flags);
449 _zfcp_erp_port_reopen(port, clear, dbftag);
450 write_unlock_irqrestore(&adapter->erp_lock, flags);
453 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
455 zfcp_erp_clear_lun_status(sdev,
456 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
459 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear,
460 char *dbftag, u32 act_status)
462 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
463 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
465 zfcp_erp_lun_block(sdev, clear);
467 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
468 zfcp_sdev->port, sdev, dbftag, act_status);
472 * zfcp_erp_lun_reopen - initiate reopen of a LUN
473 * @sdev: SCSI device / LUN to be reopened
474 * @clear: specifies flags in LUN status to be cleared
475 * @dbftag: Tag for debug trace event.
477 * Return: 0 on success, < 0 on error
479 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *dbftag)
482 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
483 struct zfcp_port *port = zfcp_sdev->port;
484 struct zfcp_adapter *adapter = port->adapter;
486 write_lock_irqsave(&adapter->erp_lock, flags);
487 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
488 write_unlock_irqrestore(&adapter->erp_lock, flags);
492 * zfcp_erp_lun_shutdown - Shutdown LUN
493 * @sdev: SCSI device / LUN to shut down.
494 * @clear: Status flags to clear.
495 * @dbftag: Tag for debug trace event.
497 void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *dbftag)
499 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
500 zfcp_erp_lun_reopen(sdev, clear | flags, dbftag);
504 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
505 * @sdev: SCSI device / LUN to shut down.
506 * @dbftag: Tag for debug trace event.
508 * Do not acquire a reference for the LUN when creating the ERP
509 * action. It is safe, because this function waits for the ERP to
510 * complete first. This allows to shutdown the LUN, even when the SCSI
511 * device is in the state SDEV_DEL when scsi_device_get will fail.
513 void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *dbftag)
516 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
517 struct zfcp_port *port = zfcp_sdev->port;
518 struct zfcp_adapter *adapter = port->adapter;
519 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
521 write_lock_irqsave(&adapter->erp_lock, flags);
522 _zfcp_erp_lun_reopen(sdev, clear, dbftag, ZFCP_STATUS_ERP_NO_REF);
523 write_unlock_irqrestore(&adapter->erp_lock, flags);
525 zfcp_erp_wait(adapter);
528 static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
530 return (atomic_read(status) ^ mask) & mask;
533 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
535 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
537 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
538 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
541 static void zfcp_erp_port_unblock(struct zfcp_port *port)
543 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
545 zfcp_dbf_rec_run("erpubl1", &port->erp_action);
546 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
549 static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
551 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
553 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
555 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
556 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
559 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
561 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
562 zfcp_dbf_rec_run("erator1", erp_action);
565 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
567 struct zfcp_adapter *adapter = act->adapter;
568 struct zfcp_fsf_req *req;
570 if (!act->fsf_req_id)
573 spin_lock(&adapter->req_list->lock);
574 req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
575 if (req && req->erp_action == act) {
576 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
577 ZFCP_STATUS_ERP_TIMEDOUT)) {
578 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
579 zfcp_dbf_rec_run("erscf_1", act);
580 /* lock-free concurrent access with
581 * zfcp_erp_timeout_handler()
583 WRITE_ONCE(req->erp_action, NULL);
585 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
586 zfcp_dbf_rec_run("erscf_2", act);
587 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
591 spin_unlock(&adapter->req_list->lock);
595 * zfcp_erp_notify - Trigger ERP action.
596 * @erp_action: ERP action to continue.
597 * @set_mask: ERP action status flags to set.
599 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
601 struct zfcp_adapter *adapter = erp_action->adapter;
604 write_lock_irqsave(&adapter->erp_lock, flags);
605 if (zfcp_erp_action_is_running(erp_action)) {
606 erp_action->status |= set_mask;
607 zfcp_erp_action_ready(erp_action);
609 write_unlock_irqrestore(&adapter->erp_lock, flags);
613 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
614 * @t: timer list entry embedded in zfcp FSF request
616 void zfcp_erp_timeout_handler(struct timer_list *t)
618 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
619 struct zfcp_erp_action *act;
621 if (fsf_req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
623 /* lock-free concurrent access with zfcp_erp_strategy_check_fsfreq() */
624 act = READ_ONCE(fsf_req->erp_action);
627 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
630 static void zfcp_erp_memwait_handler(struct timer_list *t)
632 struct zfcp_erp_action *act = from_timer(act, t, timer);
634 zfcp_erp_notify(act, 0);
637 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
639 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
640 erp_action->timer.expires = jiffies + HZ;
641 add_timer(&erp_action->timer);
644 void zfcp_erp_port_forced_reopen_all(struct zfcp_adapter *adapter,
645 int clear, char *dbftag)
648 struct zfcp_port *port;
650 write_lock_irqsave(&adapter->erp_lock, flags);
651 read_lock(&adapter->port_list_lock);
652 list_for_each_entry(port, &adapter->port_list, list)
653 _zfcp_erp_port_forced_reopen(port, clear, dbftag);
654 read_unlock(&adapter->port_list_lock);
655 write_unlock_irqrestore(&adapter->erp_lock, flags);
658 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
659 int clear, char *dbftag)
661 struct zfcp_port *port;
663 read_lock(&adapter->port_list_lock);
664 list_for_each_entry(port, &adapter->port_list, list)
665 _zfcp_erp_port_reopen(port, clear, dbftag);
666 read_unlock(&adapter->port_list_lock);
669 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
672 struct scsi_device *sdev;
674 spin_lock(port->adapter->scsi_host->host_lock);
675 __shost_for_each_device(sdev, port->adapter->scsi_host)
676 if (sdev_to_zfcp(sdev)->port == port)
677 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
678 spin_unlock(port->adapter->scsi_host->host_lock);
681 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
684 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
685 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
687 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
688 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
690 case ZFCP_ERP_ACTION_REOPEN_PORT:
691 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
693 case ZFCP_ERP_ACTION_REOPEN_LUN:
694 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
699 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
702 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
703 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
705 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
706 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
708 case ZFCP_ERP_ACTION_REOPEN_PORT:
709 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
711 case ZFCP_ERP_ACTION_REOPEN_LUN:
717 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
721 read_lock_irqsave(&adapter->erp_lock, flags);
722 if (list_empty(&adapter->erp_ready_head) &&
723 list_empty(&adapter->erp_running_head)) {
724 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
726 wake_up(&adapter->erp_done_wqh);
728 read_unlock_irqrestore(&adapter->erp_lock, flags);
731 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
733 struct zfcp_port *port;
734 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
736 if (IS_ERR(port)) /* error or port already attached */
738 zfcp_erp_port_reopen(port, 0, "ereptp1");
741 static enum zfcp_erp_act_result zfcp_erp_adapter_strat_fsf_xconf(
742 struct zfcp_erp_action *erp_action)
746 struct zfcp_adapter *adapter = erp_action->adapter;
748 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
750 for (retries = 7; retries; retries--) {
751 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
753 write_lock_irq(&adapter->erp_lock);
754 zfcp_erp_action_to_running(erp_action);
755 write_unlock_irq(&adapter->erp_lock);
756 if (zfcp_fsf_exchange_config_data(erp_action)) {
757 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
759 return ZFCP_ERP_FAILED;
762 wait_event(adapter->erp_ready_wq,
763 !list_empty(&adapter->erp_ready_head));
764 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
767 if (!(atomic_read(&adapter->status) &
768 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
775 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
778 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
779 return ZFCP_ERP_FAILED;
781 return ZFCP_ERP_SUCCEEDED;
785 zfcp_erp_adapter_strategy_open_ptp_port(struct zfcp_adapter *const adapter)
787 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
788 zfcp_erp_enqueue_ptp_port(adapter);
791 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf_xport(
792 struct zfcp_erp_action *act)
795 struct zfcp_adapter *adapter = act->adapter;
797 write_lock_irq(&adapter->erp_lock);
798 zfcp_erp_action_to_running(act);
799 write_unlock_irq(&adapter->erp_lock);
801 ret = zfcp_fsf_exchange_port_data(act);
802 if (ret == -EOPNOTSUPP)
803 return ZFCP_ERP_SUCCEEDED;
805 return ZFCP_ERP_FAILED;
807 zfcp_dbf_rec_run("erasox1", act);
808 wait_event(adapter->erp_ready_wq,
809 !list_empty(&adapter->erp_ready_head));
810 zfcp_dbf_rec_run("erasox2", act);
811 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
812 return ZFCP_ERP_FAILED;
814 return ZFCP_ERP_SUCCEEDED;
817 static enum zfcp_erp_act_result
818 zfcp_erp_adapter_strategy_alloc_shost(struct zfcp_adapter *const adapter)
820 struct zfcp_diag_adapter_config_data *const config_data =
821 &adapter->diagnostics->config_data;
822 struct zfcp_diag_adapter_port_data *const port_data =
823 &adapter->diagnostics->port_data;
827 rc = zfcp_scsi_adapter_register(adapter);
829 return ZFCP_ERP_SUCCEEDED;
831 return ZFCP_ERP_FAILED;
834 * We allocated the shost for the first time. Before it was NULL,
835 * and so we deferred all updates in the xconf- and xport-data
836 * handlers. We need to make up for that now, and make all the updates
837 * that would have been done before.
839 * We can be sure that xconf- and xport-data succeeded, because
840 * otherwise this function is not called. But they might have been
844 spin_lock_irqsave(&config_data->header.access_lock, flags);
845 zfcp_scsi_shost_update_config_data(adapter, &config_data->data,
846 !!config_data->header.incomplete);
847 spin_unlock_irqrestore(&config_data->header.access_lock, flags);
849 if (adapter->adapter_features & FSF_FEATURE_HBAAPI_MANAGEMENT) {
850 spin_lock_irqsave(&port_data->header.access_lock, flags);
851 zfcp_scsi_shost_update_port_data(adapter, &port_data->data);
852 spin_unlock_irqrestore(&port_data->header.access_lock, flags);
856 * There is a remote possibility that the 'Exchange Port Data' request
857 * reports a different connectivity status than 'Exchange Config Data'.
858 * But any change to the connectivity status of the local optic that
859 * happens after the initial xconf request is expected to be reported
860 * to us, as soon as we post Status Read Buffers to the FCP channel
861 * firmware after this function. So any resulting inconsistency will
864 if (config_data->header.incomplete)
865 zfcp_fsf_fc_host_link_down(adapter);
867 return ZFCP_ERP_SUCCEEDED;
870 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf(
871 struct zfcp_erp_action *act)
873 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
874 return ZFCP_ERP_FAILED;
876 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
877 return ZFCP_ERP_FAILED;
879 if (zfcp_erp_adapter_strategy_alloc_shost(act->adapter) ==
881 return ZFCP_ERP_FAILED;
883 zfcp_erp_adapter_strategy_open_ptp_port(act->adapter);
885 if (mempool_resize(act->adapter->pool.sr_data,
886 act->adapter->stat_read_buf_num))
887 return ZFCP_ERP_FAILED;
889 if (mempool_resize(act->adapter->pool.status_read_req,
890 act->adapter->stat_read_buf_num))
891 return ZFCP_ERP_FAILED;
893 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
894 if (zfcp_status_read_refill(act->adapter))
895 return ZFCP_ERP_FAILED;
897 return ZFCP_ERP_SUCCEEDED;
900 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
902 struct zfcp_adapter *adapter = act->adapter;
904 /* close queues to ensure that buffers are not accessed by adapter */
905 zfcp_qdio_close(adapter->qdio);
906 zfcp_fsf_req_dismiss_all(adapter);
907 adapter->fsf_req_seq_no = 0;
908 zfcp_fc_wka_ports_force_offline(adapter->gs);
909 /* all ports and LUNs are closed */
910 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
912 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
913 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
916 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open(
917 struct zfcp_erp_action *act)
919 struct zfcp_adapter *adapter = act->adapter;
921 if (zfcp_qdio_open(adapter->qdio)) {
922 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
923 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
925 return ZFCP_ERP_FAILED;
928 if (zfcp_erp_adapter_strategy_open_fsf(act)) {
929 zfcp_erp_adapter_strategy_close(act);
930 return ZFCP_ERP_FAILED;
933 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
935 return ZFCP_ERP_SUCCEEDED;
938 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy(
939 struct zfcp_erp_action *act)
941 struct zfcp_adapter *adapter = act->adapter;
943 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
944 zfcp_erp_adapter_strategy_close(act);
945 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
946 return ZFCP_ERP_EXIT;
949 if (zfcp_erp_adapter_strategy_open(act)) {
951 return ZFCP_ERP_FAILED;
954 return ZFCP_ERP_SUCCEEDED;
957 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy_close(
958 struct zfcp_erp_action *act)
962 retval = zfcp_fsf_close_physical_port(act);
963 if (retval == -ENOMEM)
964 return ZFCP_ERP_NOMEM;
965 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
967 return ZFCP_ERP_FAILED;
969 return ZFCP_ERP_CONTINUES;
972 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy(
973 struct zfcp_erp_action *erp_action)
975 struct zfcp_port *port = erp_action->port;
976 int status = atomic_read(&port->status);
978 switch (erp_action->step) {
979 case ZFCP_ERP_STEP_UNINITIALIZED:
980 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
981 (status & ZFCP_STATUS_COMMON_OPEN))
982 return zfcp_erp_port_forced_strategy_close(erp_action);
984 return ZFCP_ERP_FAILED;
986 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
987 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
988 return ZFCP_ERP_SUCCEEDED;
990 case ZFCP_ERP_STEP_PORT_CLOSING:
991 case ZFCP_ERP_STEP_PORT_OPENING:
992 case ZFCP_ERP_STEP_LUN_CLOSING:
993 case ZFCP_ERP_STEP_LUN_OPENING:
997 return ZFCP_ERP_FAILED;
1000 static enum zfcp_erp_act_result zfcp_erp_port_strategy_close(
1001 struct zfcp_erp_action *erp_action)
1005 retval = zfcp_fsf_close_port(erp_action);
1006 if (retval == -ENOMEM)
1007 return ZFCP_ERP_NOMEM;
1008 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
1010 return ZFCP_ERP_FAILED;
1011 return ZFCP_ERP_CONTINUES;
1014 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_port(
1015 struct zfcp_erp_action *erp_action)
1019 retval = zfcp_fsf_open_port(erp_action);
1020 if (retval == -ENOMEM)
1021 return ZFCP_ERP_NOMEM;
1022 erp_action->step = ZFCP_ERP_STEP_PORT_OPENING;
1024 return ZFCP_ERP_FAILED;
1025 return ZFCP_ERP_CONTINUES;
1028 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
1030 struct zfcp_adapter *adapter = act->adapter;
1031 struct zfcp_port *port = act->port;
1033 if (port->wwpn != adapter->peer_wwpn) {
1034 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
1035 return ZFCP_ERP_FAILED;
1037 port->d_id = adapter->peer_d_id;
1038 return zfcp_erp_port_strategy_open_port(act);
1041 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_common(
1042 struct zfcp_erp_action *act)
1044 struct zfcp_adapter *adapter = act->adapter;
1045 struct zfcp_port *port = act->port;
1046 int p_status = atomic_read(&port->status);
1048 switch (act->step) {
1049 case ZFCP_ERP_STEP_UNINITIALIZED:
1050 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1051 case ZFCP_ERP_STEP_PORT_CLOSING:
1052 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
1053 return zfcp_erp_open_ptp_port(act);
1055 zfcp_fc_trigger_did_lookup(port);
1056 return ZFCP_ERP_EXIT;
1058 return zfcp_erp_port_strategy_open_port(act);
1060 case ZFCP_ERP_STEP_PORT_OPENING:
1061 /* D_ID might have changed during open */
1062 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
1064 zfcp_fc_trigger_did_lookup(port);
1065 return ZFCP_ERP_EXIT;
1067 return ZFCP_ERP_SUCCEEDED;
1069 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
1071 return ZFCP_ERP_FAILED;
1073 /* no early return otherwise, continue after switch case */
1075 case ZFCP_ERP_STEP_LUN_CLOSING:
1076 case ZFCP_ERP_STEP_LUN_OPENING:
1080 return ZFCP_ERP_FAILED;
1083 static enum zfcp_erp_act_result zfcp_erp_port_strategy(
1084 struct zfcp_erp_action *erp_action)
1086 struct zfcp_port *port = erp_action->port;
1087 int p_status = atomic_read(&port->status);
1089 if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
1090 !(p_status & ZFCP_STATUS_COMMON_OPEN))
1091 goto close_init_done;
1093 switch (erp_action->step) {
1094 case ZFCP_ERP_STEP_UNINITIALIZED:
1095 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1096 return zfcp_erp_port_strategy_close(erp_action);
1099 case ZFCP_ERP_STEP_PORT_CLOSING:
1100 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1101 return ZFCP_ERP_FAILED;
1103 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1104 case ZFCP_ERP_STEP_PORT_OPENING:
1105 case ZFCP_ERP_STEP_LUN_CLOSING:
1106 case ZFCP_ERP_STEP_LUN_OPENING:
1112 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1113 return ZFCP_ERP_EXIT;
1115 return zfcp_erp_port_strategy_open_common(erp_action);
1118 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
1120 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1122 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
1123 &zfcp_sdev->status);
1126 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_close(
1127 struct zfcp_erp_action *erp_action)
1129 int retval = zfcp_fsf_close_lun(erp_action);
1130 if (retval == -ENOMEM)
1131 return ZFCP_ERP_NOMEM;
1132 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
1134 return ZFCP_ERP_FAILED;
1135 return ZFCP_ERP_CONTINUES;
1138 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_open(
1139 struct zfcp_erp_action *erp_action)
1141 int retval = zfcp_fsf_open_lun(erp_action);
1142 if (retval == -ENOMEM)
1143 return ZFCP_ERP_NOMEM;
1144 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
1146 return ZFCP_ERP_FAILED;
1147 return ZFCP_ERP_CONTINUES;
1150 static enum zfcp_erp_act_result zfcp_erp_lun_strategy(
1151 struct zfcp_erp_action *erp_action)
1153 struct scsi_device *sdev = erp_action->sdev;
1154 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1156 switch (erp_action->step) {
1157 case ZFCP_ERP_STEP_UNINITIALIZED:
1158 zfcp_erp_lun_strategy_clearstati(sdev);
1159 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1160 return zfcp_erp_lun_strategy_close(erp_action);
1161 /* already closed */
1163 case ZFCP_ERP_STEP_LUN_CLOSING:
1164 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1165 return ZFCP_ERP_FAILED;
1166 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1167 return ZFCP_ERP_EXIT;
1168 return zfcp_erp_lun_strategy_open(erp_action);
1170 case ZFCP_ERP_STEP_LUN_OPENING:
1171 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1172 return ZFCP_ERP_SUCCEEDED;
1174 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1175 case ZFCP_ERP_STEP_PORT_CLOSING:
1176 case ZFCP_ERP_STEP_PORT_OPENING:
1180 return ZFCP_ERP_FAILED;
1183 static enum zfcp_erp_act_result zfcp_erp_strategy_check_lun(
1184 struct scsi_device *sdev, enum zfcp_erp_act_result result)
1186 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1189 case ZFCP_ERP_SUCCEEDED :
1190 atomic_set(&zfcp_sdev->erp_counter, 0);
1191 zfcp_erp_lun_unblock(sdev);
1193 case ZFCP_ERP_FAILED :
1194 atomic_inc(&zfcp_sdev->erp_counter);
1195 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1196 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1197 "ERP failed for LUN 0x%016Lx on "
1199 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1200 (unsigned long long)zfcp_sdev->port->wwpn);
1201 zfcp_erp_set_lun_status(sdev,
1202 ZFCP_STATUS_COMMON_ERP_FAILED);
1205 case ZFCP_ERP_CONTINUES:
1207 case ZFCP_ERP_DISMISSED:
1208 case ZFCP_ERP_NOMEM:
1213 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1214 zfcp_erp_lun_block(sdev, 0);
1215 result = ZFCP_ERP_EXIT;
1220 static enum zfcp_erp_act_result zfcp_erp_strategy_check_port(
1221 struct zfcp_port *port, enum zfcp_erp_act_result result)
1224 case ZFCP_ERP_SUCCEEDED :
1225 atomic_set(&port->erp_counter, 0);
1226 zfcp_erp_port_unblock(port);
1229 case ZFCP_ERP_FAILED :
1230 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1231 zfcp_erp_port_block(port, 0);
1232 result = ZFCP_ERP_EXIT;
1234 atomic_inc(&port->erp_counter);
1235 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1236 dev_err(&port->adapter->ccw_device->dev,
1237 "ERP failed for remote port 0x%016Lx\n",
1238 (unsigned long long)port->wwpn);
1239 zfcp_erp_set_port_status(port,
1240 ZFCP_STATUS_COMMON_ERP_FAILED);
1243 case ZFCP_ERP_CONTINUES:
1245 case ZFCP_ERP_DISMISSED:
1246 case ZFCP_ERP_NOMEM:
1251 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1252 zfcp_erp_port_block(port, 0);
1253 result = ZFCP_ERP_EXIT;
1258 static enum zfcp_erp_act_result zfcp_erp_strategy_check_adapter(
1259 struct zfcp_adapter *adapter, enum zfcp_erp_act_result result)
1262 case ZFCP_ERP_SUCCEEDED :
1263 atomic_set(&adapter->erp_counter, 0);
1264 zfcp_erp_adapter_unblock(adapter);
1267 case ZFCP_ERP_FAILED :
1268 atomic_inc(&adapter->erp_counter);
1269 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1270 dev_err(&adapter->ccw_device->dev,
1271 "ERP cannot recover an error "
1272 "on the FCP device\n");
1273 zfcp_erp_set_adapter_status(adapter,
1274 ZFCP_STATUS_COMMON_ERP_FAILED);
1277 case ZFCP_ERP_CONTINUES:
1279 case ZFCP_ERP_DISMISSED:
1280 case ZFCP_ERP_NOMEM:
1285 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1286 zfcp_erp_adapter_block(adapter, 0);
1287 result = ZFCP_ERP_EXIT;
1292 static enum zfcp_erp_act_result zfcp_erp_strategy_check_target(
1293 struct zfcp_erp_action *erp_action, enum zfcp_erp_act_result result)
1295 struct zfcp_adapter *adapter = erp_action->adapter;
1296 struct zfcp_port *port = erp_action->port;
1297 struct scsi_device *sdev = erp_action->sdev;
1299 switch (erp_action->type) {
1301 case ZFCP_ERP_ACTION_REOPEN_LUN:
1302 result = zfcp_erp_strategy_check_lun(sdev, result);
1305 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1306 case ZFCP_ERP_ACTION_REOPEN_PORT:
1307 result = zfcp_erp_strategy_check_port(port, result);
1310 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1311 result = zfcp_erp_strategy_check_adapter(adapter, result);
1317 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1319 int status = atomic_read(target_status);
1321 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1322 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1323 return 1; /* take it online */
1325 if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1326 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1327 return 1; /* take it offline */
1332 static enum zfcp_erp_act_result zfcp_erp_strategy_statechange(
1333 struct zfcp_erp_action *act, enum zfcp_erp_act_result result)
1335 enum zfcp_erp_act_type type = act->type;
1336 struct zfcp_adapter *adapter = act->adapter;
1337 struct zfcp_port *port = act->port;
1338 struct scsi_device *sdev = act->sdev;
1339 struct zfcp_scsi_dev *zfcp_sdev;
1340 u32 erp_status = act->status;
1343 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1344 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1345 _zfcp_erp_adapter_reopen(adapter,
1346 ZFCP_STATUS_COMMON_ERP_FAILED,
1348 return ZFCP_ERP_EXIT;
1352 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1353 case ZFCP_ERP_ACTION_REOPEN_PORT:
1354 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1355 _zfcp_erp_port_reopen(port,
1356 ZFCP_STATUS_COMMON_ERP_FAILED,
1358 return ZFCP_ERP_EXIT;
1362 case ZFCP_ERP_ACTION_REOPEN_LUN:
1363 zfcp_sdev = sdev_to_zfcp(sdev);
1364 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1365 _zfcp_erp_lun_reopen(sdev,
1366 ZFCP_STATUS_COMMON_ERP_FAILED,
1368 return ZFCP_ERP_EXIT;
1375 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1377 struct zfcp_adapter *adapter = erp_action->adapter;
1378 struct zfcp_scsi_dev *zfcp_sdev;
1380 adapter->erp_total_count--;
1381 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1382 adapter->erp_low_mem_count--;
1383 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1386 list_del(&erp_action->list);
1387 zfcp_dbf_rec_run("eractd1", erp_action);
1389 switch (erp_action->type) {
1390 case ZFCP_ERP_ACTION_REOPEN_LUN:
1391 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1392 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1393 &zfcp_sdev->status);
1396 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1397 case ZFCP_ERP_ACTION_REOPEN_PORT:
1398 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1399 &erp_action->port->status);
1402 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1403 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1404 &erp_action->adapter->status);
1410 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1411 * @port: zfcp_port whose fc_rport we should try to unblock
1413 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
1415 unsigned long flags;
1416 struct zfcp_adapter *adapter = port->adapter;
1418 struct Scsi_Host *shost = adapter->scsi_host;
1419 struct scsi_device *sdev;
1421 write_lock_irqsave(&adapter->erp_lock, flags);
1422 port_status = atomic_read(&port->status);
1423 if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1424 (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
1425 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
1426 /* new ERP of severity >= port triggered elsewhere meanwhile or
1427 * local link down (adapter erp_failed but not clear unblock)
1429 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
1430 write_unlock_irqrestore(&adapter->erp_lock, flags);
1433 spin_lock(shost->host_lock);
1434 __shost_for_each_device(sdev, shost) {
1435 struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
1438 if (sdev->sdev_state == SDEV_DEL ||
1439 sdev->sdev_state == SDEV_CANCEL)
1441 if (zsdev->port != port)
1443 /* LUN under port of interest */
1444 lun_status = atomic_read(&zsdev->status);
1445 if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
1446 continue; /* unblock rport despite failed LUNs */
1447 /* LUN recovery not given up yet [maybe follow-up pending] */
1448 if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1449 (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
1451 * not yet unblocked [LUN recovery pending]
1452 * or meanwhile blocked [new LUN recovery triggered]
1454 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
1455 spin_unlock(shost->host_lock);
1456 write_unlock_irqrestore(&adapter->erp_lock, flags);
1460 /* now port has no child or all children have completed recovery,
1461 * and no ERP of severity >= port was meanwhile triggered elsewhere
1463 zfcp_scsi_schedule_rport_register(port);
1464 spin_unlock(shost->host_lock);
1465 write_unlock_irqrestore(&adapter->erp_lock, flags);
1468 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act,
1469 enum zfcp_erp_act_result result)
1471 struct zfcp_adapter *adapter = act->adapter;
1472 struct zfcp_port *port = act->port;
1473 struct scsi_device *sdev = act->sdev;
1475 switch (act->type) {
1476 case ZFCP_ERP_ACTION_REOPEN_LUN:
1477 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1478 scsi_device_put(sdev);
1479 zfcp_erp_try_rport_unblock(port);
1482 case ZFCP_ERP_ACTION_REOPEN_PORT:
1483 /* This switch case might also happen after a forced reopen
1484 * was successfully done and thus overwritten with a new
1485 * non-forced reopen at `ersfs_2'. In this case, we must not
1486 * do the clean-up of the non-forced version.
1488 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
1489 if (result == ZFCP_ERP_SUCCEEDED)
1490 zfcp_erp_try_rport_unblock(port);
1492 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1493 put_device(&port->dev);
1496 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1497 if (result == ZFCP_ERP_SUCCEEDED) {
1498 register_service_level(&adapter->service_level);
1499 zfcp_fc_conditional_port_scan(adapter);
1500 queue_work(adapter->work_queue, &adapter->ns_up_work);
1502 unregister_service_level(&adapter->service_level);
1504 kref_put(&adapter->ref, zfcp_adapter_release);
1509 static enum zfcp_erp_act_result zfcp_erp_strategy_do_action(
1510 struct zfcp_erp_action *erp_action)
1512 switch (erp_action->type) {
1513 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1514 return zfcp_erp_adapter_strategy(erp_action);
1515 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1516 return zfcp_erp_port_forced_strategy(erp_action);
1517 case ZFCP_ERP_ACTION_REOPEN_PORT:
1518 return zfcp_erp_port_strategy(erp_action);
1519 case ZFCP_ERP_ACTION_REOPEN_LUN:
1520 return zfcp_erp_lun_strategy(erp_action);
1522 return ZFCP_ERP_FAILED;
1525 static enum zfcp_erp_act_result zfcp_erp_strategy(
1526 struct zfcp_erp_action *erp_action)
1528 enum zfcp_erp_act_result result;
1529 unsigned long flags;
1530 struct zfcp_adapter *adapter = erp_action->adapter;
1532 kref_get(&adapter->ref);
1534 write_lock_irqsave(&adapter->erp_lock, flags);
1535 zfcp_erp_strategy_check_fsfreq(erp_action);
1537 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1538 zfcp_erp_action_dequeue(erp_action);
1539 result = ZFCP_ERP_DISMISSED;
1543 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1544 result = ZFCP_ERP_FAILED;
1548 zfcp_erp_action_to_running(erp_action);
1550 /* no lock to allow for blocking operations */
1551 write_unlock_irqrestore(&adapter->erp_lock, flags);
1552 result = zfcp_erp_strategy_do_action(erp_action);
1553 write_lock_irqsave(&adapter->erp_lock, flags);
1555 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1556 result = ZFCP_ERP_CONTINUES;
1559 case ZFCP_ERP_NOMEM:
1560 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1561 ++adapter->erp_low_mem_count;
1562 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1564 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1565 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1567 zfcp_erp_strategy_memwait(erp_action);
1568 result = ZFCP_ERP_CONTINUES;
1572 case ZFCP_ERP_CONTINUES:
1573 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1574 --adapter->erp_low_mem_count;
1575 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1578 case ZFCP_ERP_SUCCEEDED:
1579 case ZFCP_ERP_FAILED:
1581 case ZFCP_ERP_DISMISSED:
1587 result = zfcp_erp_strategy_check_target(erp_action, result);
1588 zfcp_erp_action_dequeue(erp_action);
1589 result = zfcp_erp_strategy_statechange(erp_action, result);
1590 if (result == ZFCP_ERP_EXIT)
1592 if (result == ZFCP_ERP_SUCCEEDED)
1593 zfcp_erp_strategy_followup_success(erp_action);
1594 if (result == ZFCP_ERP_FAILED)
1595 zfcp_erp_strategy_followup_failed(erp_action);
1598 write_unlock_irqrestore(&adapter->erp_lock, flags);
1600 if (result != ZFCP_ERP_CONTINUES)
1601 zfcp_erp_action_cleanup(erp_action, result);
1603 kref_put(&adapter->ref, zfcp_adapter_release);
1607 static int zfcp_erp_thread(void *data)
1609 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1610 struct zfcp_erp_action *act;
1611 unsigned long flags;
1614 wait_event_interruptible(adapter->erp_ready_wq,
1615 !list_empty(&adapter->erp_ready_head) ||
1616 kthread_should_stop());
1618 if (kthread_should_stop())
1621 write_lock_irqsave(&adapter->erp_lock, flags);
1622 act = list_first_entry_or_null(&adapter->erp_ready_head,
1623 struct zfcp_erp_action, list);
1624 write_unlock_irqrestore(&adapter->erp_lock, flags);
1627 /* there is more to come after dismission, no notify */
1628 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1629 zfcp_erp_wakeup(adapter);
1637 * zfcp_erp_thread_setup - Start ERP thread for adapter
1638 * @adapter: Adapter to start the ERP thread for
1640 * Return: 0 on success, or error code from kthread_run().
1642 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1644 struct task_struct *thread;
1646 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1647 dev_name(&adapter->ccw_device->dev));
1648 if (IS_ERR(thread)) {
1649 dev_err(&adapter->ccw_device->dev,
1650 "Creating an ERP thread for the FCP device failed.\n");
1651 return PTR_ERR(thread);
1654 adapter->erp_thread = thread;
1659 * zfcp_erp_thread_kill - Stop ERP thread.
1660 * @adapter: Adapter where the ERP thread should be stopped.
1662 * The caller of this routine ensures that the specified adapter has
1663 * been shut down and that this operation has been completed. Thus,
1664 * there are no pending erp_actions which would need to be handled
1667 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1669 kthread_stop(adapter->erp_thread);
1670 adapter->erp_thread = NULL;
1671 WARN_ON(!list_empty(&adapter->erp_ready_head));
1672 WARN_ON(!list_empty(&adapter->erp_running_head));
1676 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1677 * @adapter: adapter for which to wait for completion of its error recovery
1679 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1681 wait_event(adapter->erp_done_wqh,
1682 !(atomic_read(&adapter->status) &
1683 ZFCP_STATUS_ADAPTER_ERP_PENDING));
1687 * zfcp_erp_set_adapter_status - set adapter status bits
1688 * @adapter: adapter to change the status
1689 * @mask: status bits to change
1691 * Changes in common status bits are propagated to attached ports and LUNs.
1693 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1695 struct zfcp_port *port;
1696 struct scsi_device *sdev;
1697 unsigned long flags;
1698 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1700 atomic_or(mask, &adapter->status);
1705 read_lock_irqsave(&adapter->port_list_lock, flags);
1706 list_for_each_entry(port, &adapter->port_list, list)
1707 atomic_or(common_mask, &port->status);
1708 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1711 * if `scsi_host` is missing, xconfig/xport data has never completed
1712 * yet, so we can't access it, but there are also no SDEVs yet
1714 if (adapter->scsi_host == NULL)
1717 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1718 __shost_for_each_device(sdev, adapter->scsi_host)
1719 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1720 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1724 * zfcp_erp_clear_adapter_status - clear adapter status bits
1725 * @adapter: adapter to change the status
1726 * @mask: status bits to change
1728 * Changes in common status bits are propagated to attached ports and LUNs.
1730 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1732 struct zfcp_port *port;
1733 struct scsi_device *sdev;
1734 unsigned long flags;
1735 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1736 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1738 atomic_andnot(mask, &adapter->status);
1744 atomic_set(&adapter->erp_counter, 0);
1746 read_lock_irqsave(&adapter->port_list_lock, flags);
1747 list_for_each_entry(port, &adapter->port_list, list) {
1748 atomic_andnot(common_mask, &port->status);
1750 atomic_set(&port->erp_counter, 0);
1752 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1755 * if `scsi_host` is missing, xconfig/xport data has never completed
1756 * yet, so we can't access it, but there are also no SDEVs yet
1758 if (adapter->scsi_host == NULL)
1761 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1762 __shost_for_each_device(sdev, adapter->scsi_host) {
1763 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1765 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1767 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1771 * zfcp_erp_set_port_status - set port status bits
1772 * @port: port to change the status
1773 * @mask: status bits to change
1775 * Changes in common status bits are propagated to attached LUNs.
1777 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1779 struct scsi_device *sdev;
1780 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1781 unsigned long flags;
1783 atomic_or(mask, &port->status);
1788 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1789 __shost_for_each_device(sdev, port->adapter->scsi_host)
1790 if (sdev_to_zfcp(sdev)->port == port)
1791 atomic_or(common_mask,
1792 &sdev_to_zfcp(sdev)->status);
1793 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1797 * zfcp_erp_clear_port_status - clear port status bits
1798 * @port: adapter to change the status
1799 * @mask: status bits to change
1801 * Changes in common status bits are propagated to attached LUNs.
1803 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1805 struct scsi_device *sdev;
1806 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1807 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1808 unsigned long flags;
1810 atomic_andnot(mask, &port->status);
1816 atomic_set(&port->erp_counter, 0);
1818 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1819 __shost_for_each_device(sdev, port->adapter->scsi_host)
1820 if (sdev_to_zfcp(sdev)->port == port) {
1821 atomic_andnot(common_mask,
1822 &sdev_to_zfcp(sdev)->status);
1824 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1826 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1830 * zfcp_erp_set_lun_status - set lun status bits
1831 * @sdev: SCSI device / lun to set the status bits
1832 * @mask: status bits to change
1834 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1836 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1838 atomic_or(mask, &zfcp_sdev->status);
1842 * zfcp_erp_clear_lun_status - clear lun status bits
1843 * @sdev: SCSi device / lun to clear the status bits
1844 * @mask: status bits to change
1846 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1848 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1850 atomic_andnot(mask, &zfcp_sdev->status);
1852 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1853 atomic_set(&zfcp_sdev->erp_counter, 0);
1857 * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
1858 * @adapter: Pointer to zfcp_adapter to reopen.
1859 * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
1861 void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
1863 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
1864 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
1865 zfcp_erp_wait(adapter);