1 // SPDX-License-Identifier: GPL-2.0
5 * Error Recovery Procedures (ERP).
7 * Copyright IBM Corp. 2002, 2017
10 #define KMSG_COMPONENT "zfcp"
11 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
13 #include <linux/kthread.h>
15 #include "zfcp_reqlist.h"
17 #define ZFCP_MAX_ERPS 3
19 enum 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,
28 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
29 * Used to indicate that an ERP action could not be set up despite a detected
30 * need for some recovery.
32 #define ZFCP_ERP_ACTION_NONE 0xc0
34 * Eyecatcher pseudo flag to bitwise or-combine with enum zfcp_erp_act_type.
35 * Used to indicate that ERP not needed because the object has
36 * ZFCP_STATUS_COMMON_ERP_FAILED.
38 #define ZFCP_ERP_ACTION_FAILED 0xe0
40 enum zfcp_erp_act_result {
41 ZFCP_ERP_SUCCEEDED = 0,
43 ZFCP_ERP_CONTINUES = 2,
45 ZFCP_ERP_DISMISSED = 4,
49 static void zfcp_erp_adapter_block(struct zfcp_adapter *adapter, int mask)
51 zfcp_erp_clear_adapter_status(adapter,
52 ZFCP_STATUS_COMMON_UNBLOCKED | mask);
55 static bool zfcp_erp_action_is_running(struct zfcp_erp_action *act)
57 struct zfcp_erp_action *curr_act;
59 list_for_each_entry(curr_act, &act->adapter->erp_running_head, list)
65 static void zfcp_erp_action_ready(struct zfcp_erp_action *act)
67 struct zfcp_adapter *adapter = act->adapter;
69 list_move(&act->list, &act->adapter->erp_ready_head);
70 zfcp_dbf_rec_run("erardy1", act);
71 wake_up(&adapter->erp_ready_wq);
72 zfcp_dbf_rec_run("erardy2", act);
75 static void zfcp_erp_action_dismiss(struct zfcp_erp_action *act)
77 act->status |= ZFCP_STATUS_ERP_DISMISSED;
78 if (zfcp_erp_action_is_running(act))
79 zfcp_erp_action_ready(act);
82 static void zfcp_erp_action_dismiss_lun(struct scsi_device *sdev)
84 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
86 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
87 zfcp_erp_action_dismiss(&zfcp_sdev->erp_action);
90 static void zfcp_erp_action_dismiss_port(struct zfcp_port *port)
92 struct scsi_device *sdev;
94 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
95 zfcp_erp_action_dismiss(&port->erp_action);
97 spin_lock(port->adapter->scsi_host->host_lock);
98 __shost_for_each_device(sdev, port->adapter->scsi_host)
99 if (sdev_to_zfcp(sdev)->port == port)
100 zfcp_erp_action_dismiss_lun(sdev);
101 spin_unlock(port->adapter->scsi_host->host_lock);
105 static void zfcp_erp_action_dismiss_adapter(struct zfcp_adapter *adapter)
107 struct zfcp_port *port;
109 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_INUSE)
110 zfcp_erp_action_dismiss(&adapter->erp_action);
112 read_lock(&adapter->port_list_lock);
113 list_for_each_entry(port, &adapter->port_list, list)
114 zfcp_erp_action_dismiss_port(port);
115 read_unlock(&adapter->port_list_lock);
119 static enum zfcp_erp_act_type zfcp_erp_handle_failed(
120 enum zfcp_erp_act_type want, struct zfcp_adapter *adapter,
121 struct zfcp_port *port, struct scsi_device *sdev)
123 enum zfcp_erp_act_type need = want;
124 struct zfcp_scsi_dev *zsdev;
127 case ZFCP_ERP_ACTION_REOPEN_LUN:
128 zsdev = sdev_to_zfcp(sdev);
129 if (atomic_read(&zsdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
132 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
133 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED)
136 case ZFCP_ERP_ACTION_REOPEN_PORT:
137 if (atomic_read(&port->status) &
138 ZFCP_STATUS_COMMON_ERP_FAILED) {
140 /* ensure propagation of failed status to new devices */
141 zfcp_erp_set_port_status(
142 port, ZFCP_STATUS_COMMON_ERP_FAILED);
145 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
146 if (atomic_read(&adapter->status) &
147 ZFCP_STATUS_COMMON_ERP_FAILED) {
149 /* ensure propagation of failed status to new devices */
150 zfcp_erp_set_adapter_status(
151 adapter, ZFCP_STATUS_COMMON_ERP_FAILED);
159 static enum zfcp_erp_act_type zfcp_erp_required_act(enum zfcp_erp_act_type want,
160 struct zfcp_adapter *adapter,
161 struct zfcp_port *port,
162 struct scsi_device *sdev)
164 enum zfcp_erp_act_type need = want;
165 int l_status, p_status, a_status;
166 struct zfcp_scsi_dev *zfcp_sdev;
169 case ZFCP_ERP_ACTION_REOPEN_LUN:
170 zfcp_sdev = sdev_to_zfcp(sdev);
171 l_status = atomic_read(&zfcp_sdev->status);
172 if (l_status & ZFCP_STATUS_COMMON_ERP_INUSE)
174 p_status = atomic_read(&port->status);
175 if (!(p_status & ZFCP_STATUS_COMMON_RUNNING) ||
176 p_status & ZFCP_STATUS_COMMON_ERP_FAILED)
178 if (!(p_status & ZFCP_STATUS_COMMON_UNBLOCKED))
179 need = ZFCP_ERP_ACTION_REOPEN_PORT;
181 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
182 p_status = atomic_read(&port->status);
183 if (!(p_status & ZFCP_STATUS_COMMON_OPEN))
184 need = ZFCP_ERP_ACTION_REOPEN_PORT;
186 case ZFCP_ERP_ACTION_REOPEN_PORT:
187 p_status = atomic_read(&port->status);
188 if (p_status & ZFCP_STATUS_COMMON_ERP_INUSE)
190 a_status = atomic_read(&adapter->status);
191 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) ||
192 a_status & ZFCP_STATUS_COMMON_ERP_FAILED)
194 if (p_status & ZFCP_STATUS_COMMON_NOESC)
196 if (!(a_status & ZFCP_STATUS_COMMON_UNBLOCKED))
197 need = ZFCP_ERP_ACTION_REOPEN_ADAPTER;
199 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
200 a_status = atomic_read(&adapter->status);
201 if (a_status & ZFCP_STATUS_COMMON_ERP_INUSE)
203 if (!(a_status & ZFCP_STATUS_COMMON_RUNNING) &&
204 !(a_status & ZFCP_STATUS_COMMON_OPEN))
205 return 0; /* shutdown requested for closed adapter */
211 static struct zfcp_erp_action *zfcp_erp_setup_act(enum zfcp_erp_act_type need,
213 struct zfcp_adapter *adapter,
214 struct zfcp_port *port,
215 struct scsi_device *sdev)
217 struct zfcp_erp_action *erp_action;
218 struct zfcp_scsi_dev *zfcp_sdev;
221 case ZFCP_ERP_ACTION_REOPEN_LUN:
222 zfcp_sdev = sdev_to_zfcp(sdev);
223 if (!(act_status & ZFCP_STATUS_ERP_NO_REF))
224 if (scsi_device_get(sdev))
226 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE,
228 erp_action = &zfcp_sdev->erp_action;
229 WARN_ON_ONCE(erp_action->port != port);
230 WARN_ON_ONCE(erp_action->sdev != sdev);
231 if (!(atomic_read(&zfcp_sdev->status) &
232 ZFCP_STATUS_COMMON_RUNNING))
233 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
236 case ZFCP_ERP_ACTION_REOPEN_PORT:
237 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
238 if (!get_device(&port->dev))
240 zfcp_erp_action_dismiss_port(port);
241 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &port->status);
242 erp_action = &port->erp_action;
243 WARN_ON_ONCE(erp_action->port != port);
244 WARN_ON_ONCE(erp_action->sdev != NULL);
245 if (!(atomic_read(&port->status) & ZFCP_STATUS_COMMON_RUNNING))
246 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
249 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
250 kref_get(&adapter->ref);
251 zfcp_erp_action_dismiss_adapter(adapter);
252 atomic_or(ZFCP_STATUS_COMMON_ERP_INUSE, &adapter->status);
253 erp_action = &adapter->erp_action;
254 WARN_ON_ONCE(erp_action->port != NULL);
255 WARN_ON_ONCE(erp_action->sdev != NULL);
256 if (!(atomic_read(&adapter->status) &
257 ZFCP_STATUS_COMMON_RUNNING))
258 act_status |= ZFCP_STATUS_ERP_CLOSE_ONLY;
262 WARN_ON_ONCE(erp_action->adapter != adapter);
263 memset(&erp_action->list, 0, sizeof(erp_action->list));
264 memset(&erp_action->timer, 0, sizeof(erp_action->timer));
265 erp_action->step = ZFCP_ERP_STEP_UNINITIALIZED;
266 erp_action->fsf_req_id = 0;
267 erp_action->type = need;
268 erp_action->status = act_status;
273 static void zfcp_erp_action_enqueue(enum zfcp_erp_act_type want,
274 struct zfcp_adapter *adapter,
275 struct zfcp_port *port,
276 struct scsi_device *sdev,
277 char *dbftag, u32 act_status)
279 enum zfcp_erp_act_type need;
280 struct zfcp_erp_action *act;
282 need = zfcp_erp_handle_failed(want, adapter, port, sdev);
284 need = ZFCP_ERP_ACTION_FAILED; /* marker for trace */
288 if (!adapter->erp_thread) {
289 need = ZFCP_ERP_ACTION_NONE; /* marker for trace */
293 need = zfcp_erp_required_act(want, adapter, port, sdev);
297 act = zfcp_erp_setup_act(need, act_status, adapter, port, sdev);
299 need |= ZFCP_ERP_ACTION_NONE; /* marker for trace */
302 atomic_or(ZFCP_STATUS_ADAPTER_ERP_PENDING, &adapter->status);
303 ++adapter->erp_total_count;
304 list_add_tail(&act->list, &adapter->erp_ready_head);
305 wake_up(&adapter->erp_ready_wq);
307 zfcp_dbf_rec_trig(dbftag, adapter, port, sdev, want, need);
310 void zfcp_erp_port_forced_no_port_dbf(char *dbftag,
311 struct zfcp_adapter *adapter,
312 u64 port_name, u32 port_id)
315 static /* don't waste stack */ struct zfcp_port tmpport;
317 write_lock_irqsave(&adapter->erp_lock, flags);
318 /* Stand-in zfcp port with fields just good enough for
319 * zfcp_dbf_rec_trig() and zfcp_dbf_set_common().
320 * Under lock because tmpport is static.
322 atomic_set(&tmpport.status, -1); /* unknown */
323 tmpport.wwpn = port_name;
324 tmpport.d_id = port_id;
325 zfcp_dbf_rec_trig(dbftag, adapter, &tmpport, NULL,
326 ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
327 ZFCP_ERP_ACTION_NONE);
328 write_unlock_irqrestore(&adapter->erp_lock, flags);
331 static void _zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter,
332 int clear_mask, char *dbftag)
334 zfcp_erp_adapter_block(adapter, clear_mask);
335 zfcp_scsi_schedule_rports_block(adapter);
337 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER,
338 adapter, NULL, NULL, dbftag, 0);
342 * zfcp_erp_adapter_reopen - Reopen adapter.
343 * @adapter: Adapter to reopen.
344 * @clear: Status flags to clear.
345 * @dbftag: Tag for debug trace event.
347 void zfcp_erp_adapter_reopen(struct zfcp_adapter *adapter, int clear,
352 zfcp_erp_adapter_block(adapter, clear);
353 zfcp_scsi_schedule_rports_block(adapter);
355 write_lock_irqsave(&adapter->erp_lock, flags);
356 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_ADAPTER, adapter,
357 NULL, NULL, dbftag, 0);
358 write_unlock_irqrestore(&adapter->erp_lock, flags);
362 * zfcp_erp_adapter_shutdown - Shutdown adapter.
363 * @adapter: Adapter to shut down.
364 * @clear: Status flags to clear.
365 * @dbftag: Tag for debug trace event.
367 void zfcp_erp_adapter_shutdown(struct zfcp_adapter *adapter, int clear,
370 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
371 zfcp_erp_adapter_reopen(adapter, clear | flags, dbftag);
375 * zfcp_erp_port_shutdown - Shutdown port
376 * @port: Port to shut down.
377 * @clear: Status flags to clear.
378 * @dbftag: Tag for debug trace event.
380 void zfcp_erp_port_shutdown(struct zfcp_port *port, int clear, char *dbftag)
382 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
383 zfcp_erp_port_reopen(port, clear | flags, dbftag);
386 static void zfcp_erp_port_block(struct zfcp_port *port, int clear)
388 zfcp_erp_clear_port_status(port,
389 ZFCP_STATUS_COMMON_UNBLOCKED | clear);
392 static void _zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
395 zfcp_erp_port_block(port, clear);
396 zfcp_scsi_schedule_rport_block(port);
398 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT_FORCED,
399 port->adapter, port, NULL, dbftag, 0);
403 * zfcp_erp_port_forced_reopen - Forced close of port and open again
404 * @port: Port to force close and to reopen.
405 * @clear: Status flags to clear.
406 * @dbftag: Tag for debug trace event.
408 void zfcp_erp_port_forced_reopen(struct zfcp_port *port, int clear,
412 struct zfcp_adapter *adapter = port->adapter;
414 write_lock_irqsave(&adapter->erp_lock, flags);
415 _zfcp_erp_port_forced_reopen(port, clear, dbftag);
416 write_unlock_irqrestore(&adapter->erp_lock, flags);
419 static void _zfcp_erp_port_reopen(struct zfcp_port *port, int clear,
422 zfcp_erp_port_block(port, clear);
423 zfcp_scsi_schedule_rport_block(port);
425 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_PORT,
426 port->adapter, port, NULL, dbftag, 0);
430 * zfcp_erp_port_reopen - trigger remote port recovery
431 * @port: port to recover
432 * @clear: flags in port status to be cleared
433 * @dbftag: Tag for debug trace event.
435 void zfcp_erp_port_reopen(struct zfcp_port *port, int clear, char *dbftag)
438 struct zfcp_adapter *adapter = port->adapter;
440 write_lock_irqsave(&adapter->erp_lock, flags);
441 _zfcp_erp_port_reopen(port, clear, dbftag);
442 write_unlock_irqrestore(&adapter->erp_lock, flags);
445 static void zfcp_erp_lun_block(struct scsi_device *sdev, int clear_mask)
447 zfcp_erp_clear_lun_status(sdev,
448 ZFCP_STATUS_COMMON_UNBLOCKED | clear_mask);
451 static void _zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear,
452 char *dbftag, u32 act_status)
454 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
455 struct zfcp_adapter *adapter = zfcp_sdev->port->adapter;
457 zfcp_erp_lun_block(sdev, clear);
459 zfcp_erp_action_enqueue(ZFCP_ERP_ACTION_REOPEN_LUN, adapter,
460 zfcp_sdev->port, sdev, dbftag, act_status);
464 * zfcp_erp_lun_reopen - initiate reopen of a LUN
465 * @sdev: SCSI device / LUN to be reopened
466 * @clear: specifies flags in LUN status to be cleared
467 * @dbftag: Tag for debug trace event.
469 * Return: 0 on success, < 0 on error
471 void zfcp_erp_lun_reopen(struct scsi_device *sdev, int clear, char *dbftag)
474 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
475 struct zfcp_port *port = zfcp_sdev->port;
476 struct zfcp_adapter *adapter = port->adapter;
478 write_lock_irqsave(&adapter->erp_lock, flags);
479 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
480 write_unlock_irqrestore(&adapter->erp_lock, flags);
484 * zfcp_erp_lun_shutdown - Shutdown LUN
485 * @sdev: SCSI device / LUN to shut down.
486 * @clear: Status flags to clear.
487 * @dbftag: Tag for debug trace event.
489 void zfcp_erp_lun_shutdown(struct scsi_device *sdev, int clear, char *dbftag)
491 int flags = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
492 zfcp_erp_lun_reopen(sdev, clear | flags, dbftag);
496 * zfcp_erp_lun_shutdown_wait - Shutdown LUN and wait for erp completion
497 * @sdev: SCSI device / LUN to shut down.
498 * @dbftag: Tag for debug trace event.
500 * Do not acquire a reference for the LUN when creating the ERP
501 * action. It is safe, because this function waits for the ERP to
502 * complete first. This allows to shutdown the LUN, even when the SCSI
503 * device is in the state SDEV_DEL when scsi_device_get will fail.
505 void zfcp_erp_lun_shutdown_wait(struct scsi_device *sdev, char *dbftag)
508 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
509 struct zfcp_port *port = zfcp_sdev->port;
510 struct zfcp_adapter *adapter = port->adapter;
511 int clear = ZFCP_STATUS_COMMON_RUNNING | ZFCP_STATUS_COMMON_ERP_FAILED;
513 write_lock_irqsave(&adapter->erp_lock, flags);
514 _zfcp_erp_lun_reopen(sdev, clear, dbftag, ZFCP_STATUS_ERP_NO_REF);
515 write_unlock_irqrestore(&adapter->erp_lock, flags);
517 zfcp_erp_wait(adapter);
520 static int zfcp_erp_status_change_set(unsigned long mask, atomic_t *status)
522 return (atomic_read(status) ^ mask) & mask;
525 static void zfcp_erp_adapter_unblock(struct zfcp_adapter *adapter)
527 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
529 zfcp_dbf_rec_run("eraubl1", &adapter->erp_action);
530 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &adapter->status);
533 static void zfcp_erp_port_unblock(struct zfcp_port *port)
535 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
537 zfcp_dbf_rec_run("erpubl1", &port->erp_action);
538 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &port->status);
541 static void zfcp_erp_lun_unblock(struct scsi_device *sdev)
543 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
545 if (zfcp_erp_status_change_set(ZFCP_STATUS_COMMON_UNBLOCKED,
547 zfcp_dbf_rec_run("erlubl1", &sdev_to_zfcp(sdev)->erp_action);
548 atomic_or(ZFCP_STATUS_COMMON_UNBLOCKED, &zfcp_sdev->status);
551 static void zfcp_erp_action_to_running(struct zfcp_erp_action *erp_action)
553 list_move(&erp_action->list, &erp_action->adapter->erp_running_head);
554 zfcp_dbf_rec_run("erator1", erp_action);
557 static void zfcp_erp_strategy_check_fsfreq(struct zfcp_erp_action *act)
559 struct zfcp_adapter *adapter = act->adapter;
560 struct zfcp_fsf_req *req;
562 if (!act->fsf_req_id)
565 spin_lock(&adapter->req_list->lock);
566 req = _zfcp_reqlist_find(adapter->req_list, act->fsf_req_id);
567 if (req && req->erp_action == act) {
568 if (act->status & (ZFCP_STATUS_ERP_DISMISSED |
569 ZFCP_STATUS_ERP_TIMEDOUT)) {
570 req->status |= ZFCP_STATUS_FSFREQ_DISMISSED;
571 zfcp_dbf_rec_run("erscf_1", act);
572 req->erp_action = NULL;
574 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
575 zfcp_dbf_rec_run("erscf_2", act);
576 if (req->status & ZFCP_STATUS_FSFREQ_DISMISSED)
580 spin_unlock(&adapter->req_list->lock);
584 * zfcp_erp_notify - Trigger ERP action.
585 * @erp_action: ERP action to continue.
586 * @set_mask: ERP action status flags to set.
588 void zfcp_erp_notify(struct zfcp_erp_action *erp_action, unsigned long set_mask)
590 struct zfcp_adapter *adapter = erp_action->adapter;
593 write_lock_irqsave(&adapter->erp_lock, flags);
594 if (zfcp_erp_action_is_running(erp_action)) {
595 erp_action->status |= set_mask;
596 zfcp_erp_action_ready(erp_action);
598 write_unlock_irqrestore(&adapter->erp_lock, flags);
602 * zfcp_erp_timeout_handler - Trigger ERP action from timed out ERP request
603 * @t: timer list entry embedded in zfcp FSF request
605 void zfcp_erp_timeout_handler(struct timer_list *t)
607 struct zfcp_fsf_req *fsf_req = from_timer(fsf_req, t, timer);
608 struct zfcp_erp_action *act = fsf_req->erp_action;
610 zfcp_erp_notify(act, ZFCP_STATUS_ERP_TIMEDOUT);
613 static void zfcp_erp_memwait_handler(struct timer_list *t)
615 struct zfcp_erp_action *act = from_timer(act, t, timer);
617 zfcp_erp_notify(act, 0);
620 static void zfcp_erp_strategy_memwait(struct zfcp_erp_action *erp_action)
622 timer_setup(&erp_action->timer, zfcp_erp_memwait_handler, 0);
623 erp_action->timer.expires = jiffies + HZ;
624 add_timer(&erp_action->timer);
627 static void _zfcp_erp_port_reopen_all(struct zfcp_adapter *adapter,
628 int clear, char *dbftag)
630 struct zfcp_port *port;
632 read_lock(&adapter->port_list_lock);
633 list_for_each_entry(port, &adapter->port_list, list)
634 _zfcp_erp_port_reopen(port, clear, dbftag);
635 read_unlock(&adapter->port_list_lock);
638 static void _zfcp_erp_lun_reopen_all(struct zfcp_port *port, int clear,
641 struct scsi_device *sdev;
643 spin_lock(port->adapter->scsi_host->host_lock);
644 __shost_for_each_device(sdev, port->adapter->scsi_host)
645 if (sdev_to_zfcp(sdev)->port == port)
646 _zfcp_erp_lun_reopen(sdev, clear, dbftag, 0);
647 spin_unlock(port->adapter->scsi_host->host_lock);
650 static void zfcp_erp_strategy_followup_failed(struct zfcp_erp_action *act)
653 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
654 _zfcp_erp_adapter_reopen(act->adapter, 0, "ersff_1");
656 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
657 _zfcp_erp_port_forced_reopen(act->port, 0, "ersff_2");
659 case ZFCP_ERP_ACTION_REOPEN_PORT:
660 _zfcp_erp_port_reopen(act->port, 0, "ersff_3");
662 case ZFCP_ERP_ACTION_REOPEN_LUN:
663 _zfcp_erp_lun_reopen(act->sdev, 0, "ersff_4", 0);
668 static void zfcp_erp_strategy_followup_success(struct zfcp_erp_action *act)
671 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
672 _zfcp_erp_port_reopen_all(act->adapter, 0, "ersfs_1");
674 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
675 _zfcp_erp_port_reopen(act->port, 0, "ersfs_2");
677 case ZFCP_ERP_ACTION_REOPEN_PORT:
678 _zfcp_erp_lun_reopen_all(act->port, 0, "ersfs_3");
680 case ZFCP_ERP_ACTION_REOPEN_LUN:
686 static void zfcp_erp_wakeup(struct zfcp_adapter *adapter)
690 read_lock_irqsave(&adapter->erp_lock, flags);
691 if (list_empty(&adapter->erp_ready_head) &&
692 list_empty(&adapter->erp_running_head)) {
693 atomic_andnot(ZFCP_STATUS_ADAPTER_ERP_PENDING,
695 wake_up(&adapter->erp_done_wqh);
697 read_unlock_irqrestore(&adapter->erp_lock, flags);
700 static void zfcp_erp_enqueue_ptp_port(struct zfcp_adapter *adapter)
702 struct zfcp_port *port;
703 port = zfcp_port_enqueue(adapter, adapter->peer_wwpn, 0,
705 if (IS_ERR(port)) /* error or port already attached */
707 _zfcp_erp_port_reopen(port, 0, "ereptp1");
710 static enum zfcp_erp_act_result zfcp_erp_adapter_strat_fsf_xconf(
711 struct zfcp_erp_action *erp_action)
715 struct zfcp_adapter *adapter = erp_action->adapter;
717 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK, &adapter->status);
719 for (retries = 7; retries; retries--) {
720 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
722 write_lock_irq(&adapter->erp_lock);
723 zfcp_erp_action_to_running(erp_action);
724 write_unlock_irq(&adapter->erp_lock);
725 if (zfcp_fsf_exchange_config_data(erp_action)) {
726 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
728 return ZFCP_ERP_FAILED;
731 wait_event(adapter->erp_ready_wq,
732 !list_empty(&adapter->erp_ready_head));
733 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT)
736 if (!(atomic_read(&adapter->status) &
737 ZFCP_STATUS_ADAPTER_HOST_CON_INIT))
744 atomic_andnot(ZFCP_STATUS_ADAPTER_HOST_CON_INIT,
747 if (!(atomic_read(&adapter->status) & ZFCP_STATUS_ADAPTER_XCONFIG_OK))
748 return ZFCP_ERP_FAILED;
750 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
751 zfcp_erp_enqueue_ptp_port(adapter);
753 return ZFCP_ERP_SUCCEEDED;
756 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf_xport(
757 struct zfcp_erp_action *act)
760 struct zfcp_adapter *adapter = act->adapter;
762 write_lock_irq(&adapter->erp_lock);
763 zfcp_erp_action_to_running(act);
764 write_unlock_irq(&adapter->erp_lock);
766 ret = zfcp_fsf_exchange_port_data(act);
767 if (ret == -EOPNOTSUPP)
768 return ZFCP_ERP_SUCCEEDED;
770 return ZFCP_ERP_FAILED;
772 zfcp_dbf_rec_run("erasox1", act);
773 wait_event(adapter->erp_ready_wq,
774 !list_empty(&adapter->erp_ready_head));
775 zfcp_dbf_rec_run("erasox2", act);
776 if (act->status & ZFCP_STATUS_ERP_TIMEDOUT)
777 return ZFCP_ERP_FAILED;
779 return ZFCP_ERP_SUCCEEDED;
782 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open_fsf(
783 struct zfcp_erp_action *act)
785 if (zfcp_erp_adapter_strat_fsf_xconf(act) == ZFCP_ERP_FAILED)
786 return ZFCP_ERP_FAILED;
788 if (zfcp_erp_adapter_strategy_open_fsf_xport(act) == ZFCP_ERP_FAILED)
789 return ZFCP_ERP_FAILED;
791 if (mempool_resize(act->adapter->pool.sr_data,
792 act->adapter->stat_read_buf_num))
793 return ZFCP_ERP_FAILED;
795 if (mempool_resize(act->adapter->pool.status_read_req,
796 act->adapter->stat_read_buf_num))
797 return ZFCP_ERP_FAILED;
799 atomic_set(&act->adapter->stat_miss, act->adapter->stat_read_buf_num);
800 if (zfcp_status_read_refill(act->adapter))
801 return ZFCP_ERP_FAILED;
803 return ZFCP_ERP_SUCCEEDED;
806 static void zfcp_erp_adapter_strategy_close(struct zfcp_erp_action *act)
808 struct zfcp_adapter *adapter = act->adapter;
810 /* close queues to ensure that buffers are not accessed by adapter */
811 zfcp_qdio_close(adapter->qdio);
812 zfcp_fsf_req_dismiss_all(adapter);
813 adapter->fsf_req_seq_no = 0;
814 zfcp_fc_wka_ports_force_offline(adapter->gs);
815 /* all ports and LUNs are closed */
816 zfcp_erp_clear_adapter_status(adapter, ZFCP_STATUS_COMMON_OPEN);
818 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
819 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED, &adapter->status);
822 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy_open(
823 struct zfcp_erp_action *act)
825 struct zfcp_adapter *adapter = act->adapter;
827 if (zfcp_qdio_open(adapter->qdio)) {
828 atomic_andnot(ZFCP_STATUS_ADAPTER_XCONFIG_OK |
829 ZFCP_STATUS_ADAPTER_LINK_UNPLUGGED,
831 return ZFCP_ERP_FAILED;
834 if (zfcp_erp_adapter_strategy_open_fsf(act)) {
835 zfcp_erp_adapter_strategy_close(act);
836 return ZFCP_ERP_FAILED;
839 atomic_or(ZFCP_STATUS_COMMON_OPEN, &adapter->status);
841 return ZFCP_ERP_SUCCEEDED;
844 static enum zfcp_erp_act_result zfcp_erp_adapter_strategy(
845 struct zfcp_erp_action *act)
847 struct zfcp_adapter *adapter = act->adapter;
849 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_OPEN) {
850 zfcp_erp_adapter_strategy_close(act);
851 if (act->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
852 return ZFCP_ERP_EXIT;
855 if (zfcp_erp_adapter_strategy_open(act)) {
857 return ZFCP_ERP_FAILED;
860 return ZFCP_ERP_SUCCEEDED;
863 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy_close(
864 struct zfcp_erp_action *act)
868 retval = zfcp_fsf_close_physical_port(act);
869 if (retval == -ENOMEM)
870 return ZFCP_ERP_NOMEM;
871 act->step = ZFCP_ERP_STEP_PHYS_PORT_CLOSING;
873 return ZFCP_ERP_FAILED;
875 return ZFCP_ERP_CONTINUES;
878 static enum zfcp_erp_act_result zfcp_erp_port_forced_strategy(
879 struct zfcp_erp_action *erp_action)
881 struct zfcp_port *port = erp_action->port;
882 int status = atomic_read(&port->status);
884 switch (erp_action->step) {
885 case ZFCP_ERP_STEP_UNINITIALIZED:
886 if ((status & ZFCP_STATUS_PORT_PHYS_OPEN) &&
887 (status & ZFCP_STATUS_COMMON_OPEN))
888 return zfcp_erp_port_forced_strategy_close(erp_action);
890 return ZFCP_ERP_FAILED;
892 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
893 if (!(status & ZFCP_STATUS_PORT_PHYS_OPEN))
894 return ZFCP_ERP_SUCCEEDED;
896 case ZFCP_ERP_STEP_PORT_CLOSING:
897 case ZFCP_ERP_STEP_PORT_OPENING:
898 case ZFCP_ERP_STEP_LUN_CLOSING:
899 case ZFCP_ERP_STEP_LUN_OPENING:
903 return ZFCP_ERP_FAILED;
906 static enum zfcp_erp_act_result zfcp_erp_port_strategy_close(
907 struct zfcp_erp_action *erp_action)
911 retval = zfcp_fsf_close_port(erp_action);
912 if (retval == -ENOMEM)
913 return ZFCP_ERP_NOMEM;
914 erp_action->step = ZFCP_ERP_STEP_PORT_CLOSING;
916 return ZFCP_ERP_FAILED;
917 return ZFCP_ERP_CONTINUES;
920 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_port(
921 struct zfcp_erp_action *erp_action)
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;
930 return ZFCP_ERP_FAILED;
931 return ZFCP_ERP_CONTINUES;
934 static int zfcp_erp_open_ptp_port(struct zfcp_erp_action *act)
936 struct zfcp_adapter *adapter = act->adapter;
937 struct zfcp_port *port = act->port;
939 if (port->wwpn != adapter->peer_wwpn) {
940 zfcp_erp_set_port_status(port, ZFCP_STATUS_COMMON_ERP_FAILED);
941 return ZFCP_ERP_FAILED;
943 port->d_id = adapter->peer_d_id;
944 return zfcp_erp_port_strategy_open_port(act);
947 static enum zfcp_erp_act_result zfcp_erp_port_strategy_open_common(
948 struct zfcp_erp_action *act)
950 struct zfcp_adapter *adapter = act->adapter;
951 struct zfcp_port *port = act->port;
952 int p_status = atomic_read(&port->status);
955 case ZFCP_ERP_STEP_UNINITIALIZED:
956 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
957 case ZFCP_ERP_STEP_PORT_CLOSING:
958 if (fc_host_port_type(adapter->scsi_host) == FC_PORTTYPE_PTP)
959 return zfcp_erp_open_ptp_port(act);
961 zfcp_fc_trigger_did_lookup(port);
962 return ZFCP_ERP_EXIT;
964 return zfcp_erp_port_strategy_open_port(act);
966 case ZFCP_ERP_STEP_PORT_OPENING:
967 /* D_ID might have changed during open */
968 if (p_status & ZFCP_STATUS_COMMON_OPEN) {
970 zfcp_fc_trigger_did_lookup(port);
971 return ZFCP_ERP_EXIT;
973 return ZFCP_ERP_SUCCEEDED;
975 if (port->d_id && !(p_status & ZFCP_STATUS_COMMON_NOESC)) {
977 return ZFCP_ERP_FAILED;
979 /* no early return otherwise, continue after switch case */
981 case ZFCP_ERP_STEP_LUN_CLOSING:
982 case ZFCP_ERP_STEP_LUN_OPENING:
986 return ZFCP_ERP_FAILED;
989 static enum zfcp_erp_act_result zfcp_erp_port_strategy(
990 struct zfcp_erp_action *erp_action)
992 struct zfcp_port *port = erp_action->port;
993 int p_status = atomic_read(&port->status);
995 if ((p_status & ZFCP_STATUS_COMMON_NOESC) &&
996 !(p_status & ZFCP_STATUS_COMMON_OPEN))
997 goto close_init_done;
999 switch (erp_action->step) {
1000 case ZFCP_ERP_STEP_UNINITIALIZED:
1001 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1002 return zfcp_erp_port_strategy_close(erp_action);
1005 case ZFCP_ERP_STEP_PORT_CLOSING:
1006 if (p_status & ZFCP_STATUS_COMMON_OPEN)
1007 return ZFCP_ERP_FAILED;
1009 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1010 case ZFCP_ERP_STEP_PORT_OPENING:
1011 case ZFCP_ERP_STEP_LUN_CLOSING:
1012 case ZFCP_ERP_STEP_LUN_OPENING:
1018 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1019 return ZFCP_ERP_EXIT;
1021 return zfcp_erp_port_strategy_open_common(erp_action);
1024 static void zfcp_erp_lun_strategy_clearstati(struct scsi_device *sdev)
1026 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1028 atomic_andnot(ZFCP_STATUS_COMMON_ACCESS_DENIED,
1029 &zfcp_sdev->status);
1032 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_close(
1033 struct zfcp_erp_action *erp_action)
1035 int retval = zfcp_fsf_close_lun(erp_action);
1036 if (retval == -ENOMEM)
1037 return ZFCP_ERP_NOMEM;
1038 erp_action->step = ZFCP_ERP_STEP_LUN_CLOSING;
1040 return ZFCP_ERP_FAILED;
1041 return ZFCP_ERP_CONTINUES;
1044 static enum zfcp_erp_act_result zfcp_erp_lun_strategy_open(
1045 struct zfcp_erp_action *erp_action)
1047 int retval = zfcp_fsf_open_lun(erp_action);
1048 if (retval == -ENOMEM)
1049 return ZFCP_ERP_NOMEM;
1050 erp_action->step = ZFCP_ERP_STEP_LUN_OPENING;
1052 return ZFCP_ERP_FAILED;
1053 return ZFCP_ERP_CONTINUES;
1056 static enum zfcp_erp_act_result zfcp_erp_lun_strategy(
1057 struct zfcp_erp_action *erp_action)
1059 struct scsi_device *sdev = erp_action->sdev;
1060 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1062 switch (erp_action->step) {
1063 case ZFCP_ERP_STEP_UNINITIALIZED:
1064 zfcp_erp_lun_strategy_clearstati(sdev);
1065 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1066 return zfcp_erp_lun_strategy_close(erp_action);
1067 /* already closed */
1069 case ZFCP_ERP_STEP_LUN_CLOSING:
1070 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1071 return ZFCP_ERP_FAILED;
1072 if (erp_action->status & ZFCP_STATUS_ERP_CLOSE_ONLY)
1073 return ZFCP_ERP_EXIT;
1074 return zfcp_erp_lun_strategy_open(erp_action);
1076 case ZFCP_ERP_STEP_LUN_OPENING:
1077 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_OPEN)
1078 return ZFCP_ERP_SUCCEEDED;
1080 case ZFCP_ERP_STEP_PHYS_PORT_CLOSING:
1081 case ZFCP_ERP_STEP_PORT_CLOSING:
1082 case ZFCP_ERP_STEP_PORT_OPENING:
1086 return ZFCP_ERP_FAILED;
1089 static enum zfcp_erp_act_result zfcp_erp_strategy_check_lun(
1090 struct scsi_device *sdev, enum zfcp_erp_act_result result)
1092 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1095 case ZFCP_ERP_SUCCEEDED :
1096 atomic_set(&zfcp_sdev->erp_counter, 0);
1097 zfcp_erp_lun_unblock(sdev);
1099 case ZFCP_ERP_FAILED :
1100 atomic_inc(&zfcp_sdev->erp_counter);
1101 if (atomic_read(&zfcp_sdev->erp_counter) > ZFCP_MAX_ERPS) {
1102 dev_err(&zfcp_sdev->port->adapter->ccw_device->dev,
1103 "ERP failed for LUN 0x%016Lx on "
1105 (unsigned long long)zfcp_scsi_dev_lun(sdev),
1106 (unsigned long long)zfcp_sdev->port->wwpn);
1107 zfcp_erp_set_lun_status(sdev,
1108 ZFCP_STATUS_COMMON_ERP_FAILED);
1111 case ZFCP_ERP_CONTINUES:
1113 case ZFCP_ERP_DISMISSED:
1114 case ZFCP_ERP_NOMEM:
1119 if (atomic_read(&zfcp_sdev->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1120 zfcp_erp_lun_block(sdev, 0);
1121 result = ZFCP_ERP_EXIT;
1126 static enum zfcp_erp_act_result zfcp_erp_strategy_check_port(
1127 struct zfcp_port *port, enum zfcp_erp_act_result result)
1130 case ZFCP_ERP_SUCCEEDED :
1131 atomic_set(&port->erp_counter, 0);
1132 zfcp_erp_port_unblock(port);
1135 case ZFCP_ERP_FAILED :
1136 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_NOESC) {
1137 zfcp_erp_port_block(port, 0);
1138 result = ZFCP_ERP_EXIT;
1140 atomic_inc(&port->erp_counter);
1141 if (atomic_read(&port->erp_counter) > ZFCP_MAX_ERPS) {
1142 dev_err(&port->adapter->ccw_device->dev,
1143 "ERP failed for remote port 0x%016Lx\n",
1144 (unsigned long long)port->wwpn);
1145 zfcp_erp_set_port_status(port,
1146 ZFCP_STATUS_COMMON_ERP_FAILED);
1149 case ZFCP_ERP_CONTINUES:
1151 case ZFCP_ERP_DISMISSED:
1152 case ZFCP_ERP_NOMEM:
1157 if (atomic_read(&port->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1158 zfcp_erp_port_block(port, 0);
1159 result = ZFCP_ERP_EXIT;
1164 static enum zfcp_erp_act_result zfcp_erp_strategy_check_adapter(
1165 struct zfcp_adapter *adapter, enum zfcp_erp_act_result result)
1168 case ZFCP_ERP_SUCCEEDED :
1169 atomic_set(&adapter->erp_counter, 0);
1170 zfcp_erp_adapter_unblock(adapter);
1173 case ZFCP_ERP_FAILED :
1174 atomic_inc(&adapter->erp_counter);
1175 if (atomic_read(&adapter->erp_counter) > ZFCP_MAX_ERPS) {
1176 dev_err(&adapter->ccw_device->dev,
1177 "ERP cannot recover an error "
1178 "on the FCP device\n");
1179 zfcp_erp_set_adapter_status(adapter,
1180 ZFCP_STATUS_COMMON_ERP_FAILED);
1183 case ZFCP_ERP_CONTINUES:
1185 case ZFCP_ERP_DISMISSED:
1186 case ZFCP_ERP_NOMEM:
1191 if (atomic_read(&adapter->status) & ZFCP_STATUS_COMMON_ERP_FAILED) {
1192 zfcp_erp_adapter_block(adapter, 0);
1193 result = ZFCP_ERP_EXIT;
1198 static enum zfcp_erp_act_result zfcp_erp_strategy_check_target(
1199 struct zfcp_erp_action *erp_action, enum zfcp_erp_act_result result)
1201 struct zfcp_adapter *adapter = erp_action->adapter;
1202 struct zfcp_port *port = erp_action->port;
1203 struct scsi_device *sdev = erp_action->sdev;
1205 switch (erp_action->type) {
1207 case ZFCP_ERP_ACTION_REOPEN_LUN:
1208 result = zfcp_erp_strategy_check_lun(sdev, result);
1211 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1212 case ZFCP_ERP_ACTION_REOPEN_PORT:
1213 result = zfcp_erp_strategy_check_port(port, result);
1216 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1217 result = zfcp_erp_strategy_check_adapter(adapter, result);
1223 static int zfcp_erp_strat_change_det(atomic_t *target_status, u32 erp_status)
1225 int status = atomic_read(target_status);
1227 if ((status & ZFCP_STATUS_COMMON_RUNNING) &&
1228 (erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1229 return 1; /* take it online */
1231 if (!(status & ZFCP_STATUS_COMMON_RUNNING) &&
1232 !(erp_status & ZFCP_STATUS_ERP_CLOSE_ONLY))
1233 return 1; /* take it offline */
1238 static enum zfcp_erp_act_result zfcp_erp_strategy_statechange(
1239 struct zfcp_erp_action *act, enum zfcp_erp_act_result result)
1241 enum zfcp_erp_act_type type = act->type;
1242 struct zfcp_adapter *adapter = act->adapter;
1243 struct zfcp_port *port = act->port;
1244 struct scsi_device *sdev = act->sdev;
1245 struct zfcp_scsi_dev *zfcp_sdev;
1246 u32 erp_status = act->status;
1249 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1250 if (zfcp_erp_strat_change_det(&adapter->status, erp_status)) {
1251 _zfcp_erp_adapter_reopen(adapter,
1252 ZFCP_STATUS_COMMON_ERP_FAILED,
1254 return ZFCP_ERP_EXIT;
1258 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1259 case ZFCP_ERP_ACTION_REOPEN_PORT:
1260 if (zfcp_erp_strat_change_det(&port->status, erp_status)) {
1261 _zfcp_erp_port_reopen(port,
1262 ZFCP_STATUS_COMMON_ERP_FAILED,
1264 return ZFCP_ERP_EXIT;
1268 case ZFCP_ERP_ACTION_REOPEN_LUN:
1269 zfcp_sdev = sdev_to_zfcp(sdev);
1270 if (zfcp_erp_strat_change_det(&zfcp_sdev->status, erp_status)) {
1271 _zfcp_erp_lun_reopen(sdev,
1272 ZFCP_STATUS_COMMON_ERP_FAILED,
1274 return ZFCP_ERP_EXIT;
1281 static void zfcp_erp_action_dequeue(struct zfcp_erp_action *erp_action)
1283 struct zfcp_adapter *adapter = erp_action->adapter;
1284 struct zfcp_scsi_dev *zfcp_sdev;
1286 adapter->erp_total_count--;
1287 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1288 adapter->erp_low_mem_count--;
1289 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1292 list_del(&erp_action->list);
1293 zfcp_dbf_rec_run("eractd1", erp_action);
1295 switch (erp_action->type) {
1296 case ZFCP_ERP_ACTION_REOPEN_LUN:
1297 zfcp_sdev = sdev_to_zfcp(erp_action->sdev);
1298 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1299 &zfcp_sdev->status);
1302 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1303 case ZFCP_ERP_ACTION_REOPEN_PORT:
1304 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1305 &erp_action->port->status);
1308 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1309 atomic_andnot(ZFCP_STATUS_COMMON_ERP_INUSE,
1310 &erp_action->adapter->status);
1316 * zfcp_erp_try_rport_unblock - unblock rport if no more/new recovery
1317 * @port: zfcp_port whose fc_rport we should try to unblock
1319 static void zfcp_erp_try_rport_unblock(struct zfcp_port *port)
1321 unsigned long flags;
1322 struct zfcp_adapter *adapter = port->adapter;
1324 struct Scsi_Host *shost = adapter->scsi_host;
1325 struct scsi_device *sdev;
1327 write_lock_irqsave(&adapter->erp_lock, flags);
1328 port_status = atomic_read(&port->status);
1329 if ((port_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1330 (port_status & (ZFCP_STATUS_COMMON_ERP_INUSE |
1331 ZFCP_STATUS_COMMON_ERP_FAILED)) != 0) {
1332 /* new ERP of severity >= port triggered elsewhere meanwhile or
1333 * local link down (adapter erp_failed but not clear unblock)
1335 zfcp_dbf_rec_run_lvl(4, "ertru_p", &port->erp_action);
1336 write_unlock_irqrestore(&adapter->erp_lock, flags);
1339 spin_lock(shost->host_lock);
1340 __shost_for_each_device(sdev, shost) {
1341 struct zfcp_scsi_dev *zsdev = sdev_to_zfcp(sdev);
1344 if (sdev->sdev_state == SDEV_DEL ||
1345 sdev->sdev_state == SDEV_CANCEL)
1347 if (zsdev->port != port)
1349 /* LUN under port of interest */
1350 lun_status = atomic_read(&zsdev->status);
1351 if ((lun_status & ZFCP_STATUS_COMMON_ERP_FAILED) != 0)
1352 continue; /* unblock rport despite failed LUNs */
1353 /* LUN recovery not given up yet [maybe follow-up pending] */
1354 if ((lun_status & ZFCP_STATUS_COMMON_UNBLOCKED) == 0 ||
1355 (lun_status & ZFCP_STATUS_COMMON_ERP_INUSE) != 0) {
1357 * not yet unblocked [LUN recovery pending]
1358 * or meanwhile blocked [new LUN recovery triggered]
1360 zfcp_dbf_rec_run_lvl(4, "ertru_l", &zsdev->erp_action);
1361 spin_unlock(shost->host_lock);
1362 write_unlock_irqrestore(&adapter->erp_lock, flags);
1366 /* now port has no child or all children have completed recovery,
1367 * and no ERP of severity >= port was meanwhile triggered elsewhere
1369 zfcp_scsi_schedule_rport_register(port);
1370 spin_unlock(shost->host_lock);
1371 write_unlock_irqrestore(&adapter->erp_lock, flags);
1374 static void zfcp_erp_action_cleanup(struct zfcp_erp_action *act,
1375 enum zfcp_erp_act_result result)
1377 struct zfcp_adapter *adapter = act->adapter;
1378 struct zfcp_port *port = act->port;
1379 struct scsi_device *sdev = act->sdev;
1381 switch (act->type) {
1382 case ZFCP_ERP_ACTION_REOPEN_LUN:
1383 if (!(act->status & ZFCP_STATUS_ERP_NO_REF))
1384 scsi_device_put(sdev);
1385 zfcp_erp_try_rport_unblock(port);
1388 case ZFCP_ERP_ACTION_REOPEN_PORT:
1389 /* This switch case might also happen after a forced reopen
1390 * was successfully done and thus overwritten with a new
1391 * non-forced reopen at `ersfs_2'. In this case, we must not
1392 * do the clean-up of the non-forced version.
1394 if (act->step != ZFCP_ERP_STEP_UNINITIALIZED)
1395 if (result == ZFCP_ERP_SUCCEEDED)
1396 zfcp_erp_try_rport_unblock(port);
1398 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1399 put_device(&port->dev);
1402 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1403 if (result == ZFCP_ERP_SUCCEEDED) {
1404 register_service_level(&adapter->service_level);
1405 zfcp_fc_conditional_port_scan(adapter);
1406 queue_work(adapter->work_queue, &adapter->ns_up_work);
1408 unregister_service_level(&adapter->service_level);
1410 kref_put(&adapter->ref, zfcp_adapter_release);
1415 static enum zfcp_erp_act_result zfcp_erp_strategy_do_action(
1416 struct zfcp_erp_action *erp_action)
1418 switch (erp_action->type) {
1419 case ZFCP_ERP_ACTION_REOPEN_ADAPTER:
1420 return zfcp_erp_adapter_strategy(erp_action);
1421 case ZFCP_ERP_ACTION_REOPEN_PORT_FORCED:
1422 return zfcp_erp_port_forced_strategy(erp_action);
1423 case ZFCP_ERP_ACTION_REOPEN_PORT:
1424 return zfcp_erp_port_strategy(erp_action);
1425 case ZFCP_ERP_ACTION_REOPEN_LUN:
1426 return zfcp_erp_lun_strategy(erp_action);
1428 return ZFCP_ERP_FAILED;
1431 static enum zfcp_erp_act_result zfcp_erp_strategy(
1432 struct zfcp_erp_action *erp_action)
1434 enum zfcp_erp_act_result result;
1435 unsigned long flags;
1436 struct zfcp_adapter *adapter = erp_action->adapter;
1438 kref_get(&adapter->ref);
1440 write_lock_irqsave(&adapter->erp_lock, flags);
1441 zfcp_erp_strategy_check_fsfreq(erp_action);
1443 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED) {
1444 zfcp_erp_action_dequeue(erp_action);
1445 result = ZFCP_ERP_DISMISSED;
1449 if (erp_action->status & ZFCP_STATUS_ERP_TIMEDOUT) {
1450 result = ZFCP_ERP_FAILED;
1454 zfcp_erp_action_to_running(erp_action);
1456 /* no lock to allow for blocking operations */
1457 write_unlock_irqrestore(&adapter->erp_lock, flags);
1458 result = zfcp_erp_strategy_do_action(erp_action);
1459 write_lock_irqsave(&adapter->erp_lock, flags);
1461 if (erp_action->status & ZFCP_STATUS_ERP_DISMISSED)
1462 result = ZFCP_ERP_CONTINUES;
1465 case ZFCP_ERP_NOMEM:
1466 if (!(erp_action->status & ZFCP_STATUS_ERP_LOWMEM)) {
1467 ++adapter->erp_low_mem_count;
1468 erp_action->status |= ZFCP_STATUS_ERP_LOWMEM;
1470 if (adapter->erp_total_count == adapter->erp_low_mem_count)
1471 _zfcp_erp_adapter_reopen(adapter, 0, "erstgy1");
1473 zfcp_erp_strategy_memwait(erp_action);
1474 result = ZFCP_ERP_CONTINUES;
1478 case ZFCP_ERP_CONTINUES:
1479 if (erp_action->status & ZFCP_STATUS_ERP_LOWMEM) {
1480 --adapter->erp_low_mem_count;
1481 erp_action->status &= ~ZFCP_STATUS_ERP_LOWMEM;
1484 case ZFCP_ERP_SUCCEEDED:
1485 case ZFCP_ERP_FAILED:
1487 case ZFCP_ERP_DISMISSED:
1493 result = zfcp_erp_strategy_check_target(erp_action, result);
1494 zfcp_erp_action_dequeue(erp_action);
1495 result = zfcp_erp_strategy_statechange(erp_action, result);
1496 if (result == ZFCP_ERP_EXIT)
1498 if (result == ZFCP_ERP_SUCCEEDED)
1499 zfcp_erp_strategy_followup_success(erp_action);
1500 if (result == ZFCP_ERP_FAILED)
1501 zfcp_erp_strategy_followup_failed(erp_action);
1504 write_unlock_irqrestore(&adapter->erp_lock, flags);
1506 if (result != ZFCP_ERP_CONTINUES)
1507 zfcp_erp_action_cleanup(erp_action, result);
1509 kref_put(&adapter->ref, zfcp_adapter_release);
1513 static int zfcp_erp_thread(void *data)
1515 struct zfcp_adapter *adapter = (struct zfcp_adapter *) data;
1516 struct list_head *next;
1517 struct zfcp_erp_action *act;
1518 unsigned long flags;
1521 wait_event_interruptible(adapter->erp_ready_wq,
1522 !list_empty(&adapter->erp_ready_head) ||
1523 kthread_should_stop());
1525 if (kthread_should_stop())
1528 write_lock_irqsave(&adapter->erp_lock, flags);
1529 next = adapter->erp_ready_head.next;
1530 write_unlock_irqrestore(&adapter->erp_lock, flags);
1532 if (next != &adapter->erp_ready_head) {
1533 act = list_entry(next, struct zfcp_erp_action, list);
1535 /* there is more to come after dismission, no notify */
1536 if (zfcp_erp_strategy(act) != ZFCP_ERP_DISMISSED)
1537 zfcp_erp_wakeup(adapter);
1545 * zfcp_erp_thread_setup - Start ERP thread for adapter
1546 * @adapter: Adapter to start the ERP thread for
1548 * Return: 0 on success, or error code from kthread_run().
1550 int zfcp_erp_thread_setup(struct zfcp_adapter *adapter)
1552 struct task_struct *thread;
1554 thread = kthread_run(zfcp_erp_thread, adapter, "zfcperp%s",
1555 dev_name(&adapter->ccw_device->dev));
1556 if (IS_ERR(thread)) {
1557 dev_err(&adapter->ccw_device->dev,
1558 "Creating an ERP thread for the FCP device failed.\n");
1559 return PTR_ERR(thread);
1562 adapter->erp_thread = thread;
1567 * zfcp_erp_thread_kill - Stop ERP thread.
1568 * @adapter: Adapter where the ERP thread should be stopped.
1570 * The caller of this routine ensures that the specified adapter has
1571 * been shut down and that this operation has been completed. Thus,
1572 * there are no pending erp_actions which would need to be handled
1575 void zfcp_erp_thread_kill(struct zfcp_adapter *adapter)
1577 kthread_stop(adapter->erp_thread);
1578 adapter->erp_thread = NULL;
1579 WARN_ON(!list_empty(&adapter->erp_ready_head));
1580 WARN_ON(!list_empty(&adapter->erp_running_head));
1584 * zfcp_erp_wait - wait for completion of error recovery on an adapter
1585 * @adapter: adapter for which to wait for completion of its error recovery
1587 void zfcp_erp_wait(struct zfcp_adapter *adapter)
1589 wait_event(adapter->erp_done_wqh,
1590 !(atomic_read(&adapter->status) &
1591 ZFCP_STATUS_ADAPTER_ERP_PENDING));
1595 * zfcp_erp_set_adapter_status - set adapter status bits
1596 * @adapter: adapter to change the status
1597 * @mask: status bits to change
1599 * Changes in common status bits are propagated to attached ports and LUNs.
1601 void zfcp_erp_set_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1603 struct zfcp_port *port;
1604 struct scsi_device *sdev;
1605 unsigned long flags;
1606 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1608 atomic_or(mask, &adapter->status);
1613 read_lock_irqsave(&adapter->port_list_lock, flags);
1614 list_for_each_entry(port, &adapter->port_list, list)
1615 atomic_or(common_mask, &port->status);
1616 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1618 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1619 __shost_for_each_device(sdev, adapter->scsi_host)
1620 atomic_or(common_mask, &sdev_to_zfcp(sdev)->status);
1621 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1625 * zfcp_erp_clear_adapter_status - clear adapter status bits
1626 * @adapter: adapter to change the status
1627 * @mask: status bits to change
1629 * Changes in common status bits are propagated to attached ports and LUNs.
1631 void zfcp_erp_clear_adapter_status(struct zfcp_adapter *adapter, u32 mask)
1633 struct zfcp_port *port;
1634 struct scsi_device *sdev;
1635 unsigned long flags;
1636 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1637 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1639 atomic_andnot(mask, &adapter->status);
1645 atomic_set(&adapter->erp_counter, 0);
1647 read_lock_irqsave(&adapter->port_list_lock, flags);
1648 list_for_each_entry(port, &adapter->port_list, list) {
1649 atomic_andnot(common_mask, &port->status);
1651 atomic_set(&port->erp_counter, 0);
1653 read_unlock_irqrestore(&adapter->port_list_lock, flags);
1655 spin_lock_irqsave(adapter->scsi_host->host_lock, flags);
1656 __shost_for_each_device(sdev, adapter->scsi_host) {
1657 atomic_andnot(common_mask, &sdev_to_zfcp(sdev)->status);
1659 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1661 spin_unlock_irqrestore(adapter->scsi_host->host_lock, flags);
1665 * zfcp_erp_set_port_status - set port status bits
1666 * @port: port to change the status
1667 * @mask: status bits to change
1669 * Changes in common status bits are propagated to attached LUNs.
1671 void zfcp_erp_set_port_status(struct zfcp_port *port, u32 mask)
1673 struct scsi_device *sdev;
1674 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1675 unsigned long flags;
1677 atomic_or(mask, &port->status);
1682 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1683 __shost_for_each_device(sdev, port->adapter->scsi_host)
1684 if (sdev_to_zfcp(sdev)->port == port)
1685 atomic_or(common_mask,
1686 &sdev_to_zfcp(sdev)->status);
1687 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1691 * zfcp_erp_clear_port_status - clear port status bits
1692 * @port: adapter to change the status
1693 * @mask: status bits to change
1695 * Changes in common status bits are propagated to attached LUNs.
1697 void zfcp_erp_clear_port_status(struct zfcp_port *port, u32 mask)
1699 struct scsi_device *sdev;
1700 u32 common_mask = mask & ZFCP_COMMON_FLAGS;
1701 u32 clear_counter = mask & ZFCP_STATUS_COMMON_ERP_FAILED;
1702 unsigned long flags;
1704 atomic_andnot(mask, &port->status);
1710 atomic_set(&port->erp_counter, 0);
1712 spin_lock_irqsave(port->adapter->scsi_host->host_lock, flags);
1713 __shost_for_each_device(sdev, port->adapter->scsi_host)
1714 if (sdev_to_zfcp(sdev)->port == port) {
1715 atomic_andnot(common_mask,
1716 &sdev_to_zfcp(sdev)->status);
1718 atomic_set(&sdev_to_zfcp(sdev)->erp_counter, 0);
1720 spin_unlock_irqrestore(port->adapter->scsi_host->host_lock, flags);
1724 * zfcp_erp_set_lun_status - set lun status bits
1725 * @sdev: SCSI device / lun to set the status bits
1726 * @mask: status bits to change
1728 void zfcp_erp_set_lun_status(struct scsi_device *sdev, u32 mask)
1730 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1732 atomic_or(mask, &zfcp_sdev->status);
1736 * zfcp_erp_clear_lun_status - clear lun status bits
1737 * @sdev: SCSi device / lun to clear the status bits
1738 * @mask: status bits to change
1740 void zfcp_erp_clear_lun_status(struct scsi_device *sdev, u32 mask)
1742 struct zfcp_scsi_dev *zfcp_sdev = sdev_to_zfcp(sdev);
1744 atomic_andnot(mask, &zfcp_sdev->status);
1746 if (mask & ZFCP_STATUS_COMMON_ERP_FAILED)
1747 atomic_set(&zfcp_sdev->erp_counter, 0);
1751 * zfcp_erp_adapter_reset_sync() - Really reopen adapter and wait.
1752 * @adapter: Pointer to zfcp_adapter to reopen.
1753 * @dbftag: Trace tag string of length %ZFCP_DBF_TAG_LEN.
1755 void zfcp_erp_adapter_reset_sync(struct zfcp_adapter *adapter, char *dbftag)
1757 zfcp_erp_set_adapter_status(adapter, ZFCP_STATUS_COMMON_RUNNING);
1758 zfcp_erp_adapter_reopen(adapter, ZFCP_STATUS_COMMON_ERP_FAILED, dbftag);
1759 zfcp_erp_wait(adapter);